DEV Community: Crafts 69 Guy

Unleash the Neovim Beast: Master Your LazyVim Setup with Real Developer Workflows (Part 3)

Crafts 69 Guy — Thu, 28 Aug 2025 13:49:22 +0000

Welcome Back, LazyVim Warriors!
Your Complete Plugin Arsenal
- Coding Superpowers
- LSP Magic for Web Development
- UI That Actually Helps
- Editor Ninja Tools
Step-by-Step: Build Your Dream Setup
- Perfect Your Solarized Osaka Theme
- Supercharge Your Coding with Smart Plugins
- Master Web Development with Perfect LSP
- Create a Beautiful, Functional Interface
- Essential Editor Tools for Daily Work
Custom Power Tools (The Secret Sauce!)
- The Cowboy Discipline System
- Smart File & Path Utilities
- Color Conversion Magic
- LSP Enhancement Helpers
Pro Developer Workflows
- Morning Setup Routine
- Debugging Like a Boss
- File Navigation Mastery
Keep It Fast: Performance Tips
When Things Break: Troubleshooting Guide
Your Next Level Journey

Welcome Back, LazyVim Warriors! 🤠

If you've followed Part 1 (LazyVim installation) and Part 2 (basic customization), you're ready for the REAL power!

What you'll get in this final part:

Production-ready plugin configurations (copy-paste friendly!)
Custom utilities that solve real developer problems
Workflows used by professional full-stack developers
A setup that's fast, reliable, and actually fun to use

Let's turn your LazyVim into a development beast! 🔥

Your Complete Plugin Arsenal 🛡️

Coding Superpowers

Blink.cmp: Lightning-fast autocompletion with AI assistance (Codeium)
Inc-rename: Rename variables with live preview across your entire project
Mini.bracketed: Navigate through code like a pro (functions, errors, etc.)
Dial.nvim: Smart increment/decrement (numbers, dates, booleans, even const/let!)
Symbols Outline: Bird's eye view of your code structure
Marks.nvim: Never lose your place in large files

LSP Magic for Web Development

TypeScript/JavaScript: Full intellisense with inlay hints
CSS/Tailwind: Smart styling assistance
HTML: Complete tag and attribute completion
Mason: Automatic language server management
Perfect Diagnostics: Error handling that doesn't annoy you

UI That Actually Helps

Snacks Dashboard: Beautiful startup screen with your recent projects
Incline.nvim: Smart filename display with file icons
Bufferline: Clean tab management
Lualine: Information-rich status line
Zen Mode: Distraction-free coding sessions
Color Highlights: See your CSS colors in real-time

Editor Ninja Tools

Telescope: Find anything, anywhere (files, text, commands)
Neo-tree: Project navigation made simple
Git Integration: Version control without leaving your editor
Close Buffers: Smart buffer cleanup
Conform + Biome: Lightning-fast code formatting

Step by Step: Build Your Dream Setup

Perfect Your Solarized Osaka Theme

First, let's get your theme setup perfected from Part 2!

Create: lua/plugins/colorscheme.lua

return {
  {
    "craftzdog/solarized-osaka.nvim",
    lazy = true,
    priority = 1000,
    opts = function()
      return {
        transparent = true, -- Makes your terminal background show through
      }
    end,
  },
}

It's will look like this

Yeahh, I'm a big fan of the solarized-osaka theme, so thanks so much Takuya Matsuyama!

🎨 Advanced Theme Customization:

Want to customize colors for specific plugins? Add this to your theme config:

return {
  {
    "craftzdog/solarized-osaka.nvim",
    lazy = true,
    priority = 1000,
    opts = function()
      return {
        transparent = true,
        on_colors = function(colors)
          -- Customize specific colors
          colors.hint = colors.orange -- Make hints more visible
          colors.error = colors.red    -- Error color
        end,
        on_highlights = function(highlights, colors)
          -- Customize specific highlight groups
          highlights.Comment = { fg = colors.base01, italic = true }
          highlights["@keyword"] = { fg = colors.violet, bold = true }
        end,
      }
    end,
  },
}

🔗 Theme Integration with Your UI Plugins:

Notice how your UI plugins use the theme colors:

-- In your incline.nvim config (from ui.lua)
local colors = require("solarized-osaka.colors").setup()
-- This ensures your filename bar matches your theme perfectly!

Why This Setup Rocks:

Transparent background: Your terminal's background shows through
Consistent colors: All plugins use the same color palette
Customizable: Override any color you don't like
Performance: Lazy-loaded with high priority for instant theming

Supercharge Your Coding with Smart Plugins

Create: lua/plugins/coding.lua

return {
  -- Lightning-fast completion with AI
  {
    "saghen/blink.cmp",
    dependencies = {
      "codeium.nvim",
      "saghen/blink.compat",
      "rafamadriz/friendly-snippets",
    },
    opts = {
      -- AI-powered completions
      sources = {
        compat = { "codeium" },
        default = { "lsp", "path", "snippets", "buffer" },
        providers = {
          codeium = {
            kind = "Codeium",
            score_offset = 100, -- Prioritize AI suggestions
            async = true,
          },
        },
      },

      keymap = {
        preset = "enter",
        ["<C-y>"] = { "select_and_accept" }, -- Accept with Ctrl+y
      },

      appearance = {
        nerd_font_variant = "mono",
      },
    },
  },

  -- Rename with live preview
  {
    "smjonas/inc-rename.nvim",
    cmd = "IncRename",
    config = true,
  },

  -- Navigate like a pro
  {
    "echasnovski/mini.bracketed",
    event = "BufReadPost",
    config = function()
      require("mini.bracketed").setup({
        file = { suffix = "" },
        window = { suffix = "" },
        quickfix = { suffix = "" },
        yank = { suffix = "" },
        treesitter = { suffix = "n" },
      })
    end,
  },

  -- Smart increment/decrement
  {
    "monaqa/dial.nvim",
    keys = {
      { "<C-a>", function() return require("dial.map").inc_normal() end, expr = true },
      { "<C-x>", function() return require("dial.map").dec_normal() end, expr = true },
    },
    config = function()
      local augend = require("dial.augend")
      require("dial.config").augends:register_group({
        default = {
          augend.integer.alias.decimal,
          augend.integer.alias.hex,
          augend.date.alias["%Y/%m/%d"],
          augend.constant.alias.bool,
          augend.semver.alias.semver,
          augend.constant.new({ elements = { "let", "const" } }), -- Toggle let/const
        },
      })
    end,
  },

  -- Code structure overview
  {
    "simrat39/symbols-outline.nvim",
    keys = { { "<leader>cs", "<cmd>SymbolsOutline<cr>", desc = "Symbols Outline" } },
    cmd = "SymbolsOutline",
    opts = {
      position = "right",
    },
  },

  -- Never lose your place
  {
    "chentoast/marks.nvim",
    event = "VeryLazy",
    opts = {},
  },
}

🎯 Why These Plugins Rock:

Blink.cmp: Faster than nvim-cmp with AI suggestions
Inc-rename: See all changes before committing
Dial: Turn true → false, Monday → Tuesday, let → const
Mini.bracketed: Use ]f to jump to next function, ]d for next diagnostic

Master Web Development with Perfect LSP

Create: lua/plugins/lsp.lua

return {
  -- Auto-install LSP servers
  {
    "williamboman/mason.nvim",
    opts = function(_, opts)
      vim.list_extend(opts.ensure_installed, {
        "typescript-language-server",
        "css-lsp",
        "tailwindcss-language-server",
        "biome", -- Fast formatter/linter
      })
    end,
  },

  -- LSP configuration
  {
    "neovim/nvim-lspconfig",
    opts = {
      inlay_hints = { enabled = false }, -- Toggle when needed
      servers = {
        -- TypeScript/JavaScript powerhouse
        tsserver = {
          root_dir = function(...)
            return require("lspconfig.util").root_pattern(".git")(...)
          end,
          settings = {
            typescript = {
              inlayHints = {
                includeInlayParameterNameHints = "literal",
                includeInlayParameterNameHintsWhenArgumentMatchesName = false,
                includeInlayFunctionParameterTypeHints = true,
                includeInlayVariableTypeHints = false,
                includeInlayPropertyDeclarationTypeHints = true,
              },
            },
            javascript = {
              inlayHints = {
                includeInlayParameterNameHints = "all",
                includeInlayParameterNameHintsWhenArgumentMatchesName = false,
                includeInlayFunctionParameterTypeHints = true,
              },
            },
          },
        },

        -- CSS intellisense
        cssls = {},

        -- Tailwind CSS support
        tailwindcss = {
          root_dir = function(...)
            return require("lspconfig.util").root_pattern(".git")(...)
          end,
        },

        -- HTML support
        html = {},
      },
    },
  },
}

🔥 Pro Tips:

Mason auto-installs everything you need
Inlay hints show parameter types (toggle with custom keymap later!)
Root detection ensures proper project context

Create a Beautiful, Functional Interface

Create: lua/plugins/ui.lua

return {
  -- Beautiful dashboard
  {
    "folke/snacks.nvim",
    opts = {
      dashboard = {
        preset = {
          header = [[
Your custom ASCII art here (keep it simple!)
Welcome back, developer! 🚀
          ]],
        },
      },
    },
  },

  -- Smart filename display
  {
    "b0o/incline.nvim",
    dependencies = { "craftzdog/solarized-osaka.nvim" },
    event = "BufReadPre",
    config = function()
      local colors = require("solarized-osaka.colors").setup()
      require("incline").setup({
        highlight = {
          groups = {
            InclineNormal = { guibg = colors.magenta500, guifg = colors.base04 },
            InclineNormalNC = { guifg = colors.violet500, guibg = colors.base03 },
          },
        },
        window = { margin = { vertical = 0, horizontal = 1 } },
        render = function(props)
          local filename = vim.fn.fnamemodify(vim.api.nvim_buf_get_name(props.buf), ":t")
          if vim.bo[props.buf].modified then
            filename = "[+] " .. filename
          end
          local icon, color = require("nvim-web-devicons").get_icon_color(filename)
          return { { icon, guifg = color }, { " " }, { filename } }
        end,
      })
    end,
  },

  -- Distraction-free coding
  {
    "folke/zen-mode.nvim",
    cmd = "ZenMode",
    keys = { { "<leader>z", "<cmd>ZenMode<cr>", desc = "Zen Mode" } },
    opts = {
      plugins = {
        gitsigns = true,
        tmux = true,
      },
    },
  },

  -- Clean buffer tabs
  {
    "akinsho/bufferline.nvim",
    opts = {
      options = {
        mode = "tabs",
        show_buffer_close_icons = false,
        show_close_icon = false,
      },
    },
  },
}

Essential Editor Tools for Daily Work

Create: lua/plugins/editor.lua

return {
  -- See colors in your CSS files
  {
    "brenoprata10/nvim-highlight-colors",
    event = "BufReadPre",
    opts = {
      render = "background",
      enable_hex = true,
      enable_short_hex = true,
      enable_rgb = true,
      enable_hsl = true,
      enable_tailwind = true,
    },
  },

  -- Git integration
  {
    "dinhhuy258/git.nvim",
    event = "BufReadPre",
    opts = {
      keymaps = {
        blame = "<Leader>gb", -- See who wrote this code
        browse = "<Leader>go", -- Open on GitHub
      },
    },
  },

  -- Enhanced Telescope
  {
    "nvim-telescope/telescope.nvim",
    dependencies = {
      "nvim-telescope/telescope-fzf-native.nvim",
      "nvim-telescope/telescope-file-browser.nvim",
    },
    keys = {
      -- Your actual keymaps from config
      { ";f", function() require("telescope.builtin").find_files({ hidden = true }) end, desc = "Find Files" },
      { ";r", function() require("telescope.builtin").live_grep({ additional_args = { "--hidden" } }) end, desc = "Live Grep" },
      { "\\\\", function() require("telescope.builtin").buffers() end, desc = "Buffers" },
      { ";;", function() require("telescope.builtin").resume() end, desc = "Resume" },
    },
  },

  -- Smart buffer management
  {
    "kazhala/close-buffers.nvim",
    event = "VeryLazy",
    keys = {
      { "<leader>th", function() require("close_buffers").delete({ type = "hidden" }) end, desc = "Close Hidden Buffers" },
      { "<leader>tu", function() require("close_buffers").delete({ type = "nameless" }) end, desc = "Close Nameless Buffers" },
    },
  },
}

Custom Power Tools (The Secret Sauce!) 🥷

The Cowboy Discipline System

Create: lua/insideee-dev/discipline.lua

local M = {}

function M.cowboy()
  -- Prevent excessive use of hjkl and arrow keys
  for _, key in ipairs({ "h", "j", "k", "l", "+", "-" }) do
    local count = 0
    local timer = assert(vim.uv.new_timer())
    local map = key
    vim.keymap.set("n", key, function()
      if vim.v.count > 0 then
        count = 0
      end
      if count >= 10 and vim.bo.buftype ~= "nofile" then
        vim.notify("Hold it Cowboy! 🤠", vim.log.levels.WARN, {
          icon = "🤠",
          id = "cowboy",
        })
      else
        count = count + 1
        timer:start(2000, 0, function()
          count = 0
        end)
        return map
      end
    end, { expr = true, silent = true })
  end
end

return M

🤠 What This Does:

Prevents you from spamming hjkl keys (builds better habits!)
Encourages using proper Vim motions like w, b, f, t
Shows a fun cowboy notification when you need to slow down

Smart File & Path Utilities

Create: lua/insideee-dev/utils.lua

local M = {}

-- Copy relative path of current file to clipboard
function M.copy_to_clipboard(has_current_line)
  local current_file_name = vim.fn.expand("%")
  local relative_path = vim.fn.fnamemodify(current_file_name, ":.")

  if has_current_line then
    relative_path = relative_path .. ":" .. vim.fn.line(".")
  end

  vim.fn.setreg("+", relative_path)

  local message = has_current_line and "Copied with line: " or "Copied path: "
  vim.notify(message .. relative_path, vim.log.levels.INFO)
end

-- Helper functions for table manipulation
function M.shallow_copy(t)
  local copy = {}
  for k, v in pairs(t) do
    copy[k] = v
  end
  return copy
end

function M.shallow_merge(table_1st, table_2nd)
  local result = M.shallow_copy(table_1st)
  for k, v in pairs(table_2nd) do
    result[k] = v
  end
  return result
end

return M

Color Conversion Magic

Add to your utils.lua:

-- Convert hex colors to HSL (great for CSS work!)
function M.hex_to_HSL(hex)
  -- Your existing color conversion functions here
  local rgb = M.hex_to_rgb(hex)
  local h, s, l = M.rgb_to_hsl(rgb[1], rgb[2], rgb[3])
  return string.format("hsl(%d, %d%%, %d%%)", math.floor(h + 0.5), math.floor(s + 0.5), math.floor(l + 0.5))
end

function M.replace_hex_with_HSL()
  local line_number = vim.api.nvim_win_get_cursor(0)[1]
  local line_content = vim.api.nvim_buf_get_lines(0, line_number - 1, line_number, false)[1]

  -- Find and replace hex codes
  for hex in line_content:gmatch("#[0-9a-fA-F]+") do
    local hsl = M.hex_to_HSL(hex)
    line_content = line_content:gsub(hex, hsl)
  end

  vim.api.nvim_buf_set_lines(0, line_number - 1, line_number, false, { line_content })
end

🎨 Real-world use: Convert #3b82f6 to hsl(217, 91%, 60%) instantly!

LSP Enhancement Helpers

Create: lua/insideee-dev/lsp.lua

local M = {}

function M.toggleInlayHints()
  vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled())
end

return M

Wire Everything Up in Keymaps {#wire-up-keymaps}

Add to your lua/config/keymaps.lua:

local discipline = require("insideee-dev.discipline")
local utils = require("insideee-dev.utils")

-- Enable cowboy discipline
discipline.cowboy()

-- File path utilities
keymap.set("n", "<Leader>yr", function()
  utils.copy_to_clipboard()
end, { desc = "Copy relative path" })

keymap.set("n", "<Leader>yR", function()
  utils.copy_to_clipboard(true)
end, { desc = "Copy path with line number" })

-- Color conversion magic
keymap.set("n", "<leader>r", function()
  utils.replace_hex_with_HSL()
end, { desc = "Replace hex with HSL" })

-- LSP helpers
keymap.set("n", "<leader>i", function()
  require("insideee-dev.lsp").toggleInlayHints()
end, { desc = "Toggle inlay hints" })

Pro Developer Workflows 💪

Morning Setup Routine

Your daily startup sequence:

Open project: nvim (see your custom dashboard!)
Recent files: ;f → type project name
Search TODOs: ;r → type "TODO"
Check git status: <leader>gg (if you have lazygit)
Review diagnostics: <leader>xx

Debugging Like a Boss

When code breaks:

Jump to error: <C-j> (next diagnostic)
Show details: <leader>cd (line diagnostics)
Quick fix: <leader>ca (code actions)
Restart LSP: :LspRestart if needed
Format code: <leader>cf (with Biome)

File Navigation Mastery

Become a navigation ninja:

]n / [n - Next/previous treesitter node (function, class, etc.)
]d / [d - Next/previous diagnostic
<C-j> - Jump to next diagnostic (your custom keymap)
<leader>1-6 - Jump to specific buffer
sf - Browse files in current directory
;; - Resume last telescope search

Keep It Fast: Performance Tips ⚡

Your setup is already optimized, but here's why:

Lazy Loading: Plugins load only when needed
Event-based Loading: BufReadPre, VeryLazy, etc.
Minimal Startup: Essential plugins only
Smart Defaults: Pre-configured for speed

Check your startup time:

nvim --startuptime startup.log

Profile plugins:

:Lazy profile

When Things Break: Troubleshooting Guide 🔧

LSP Not Working?

:Mason - Check installed servers
:LspInfo - See attached servers
:LspRestart - Restart language server
Check project has package.json or .git

Completion Not Showing?

:Lazy sync - Update plugins
Check Codeium is working: :Codeium Auth
Restart nvim completely

Telescope Errors?

Install dependencies: brew install ripgrep fd
:checkhealth telescope - Check setup
Clear cache: rm -rf ~/.local/share/nvim

Performance Issues?

:Lazy profile - Find slow plugins
Disable unused TreeSitter parsers
Check for plugin conflicts

Your Next Level Journey 🚀

Congratulations! You're now a LazyVim Beast! 🦁

You've mastered:

✅ Production-ready plugin configuration
✅ Custom utilities that save time daily
✅ Professional developer workflows
✅ Performance optimization
✅ Troubleshooting skills

Keep growing:

Explore language-specific plugins
Create custom snippets for your projects
Contribute to the LazyVim community
Share your setup with other developers

Advanced topics to explore later:

Custom plugin development
Advanced Lua scripting
Integration with external tools (Docker, databases)
Team configuration management

You're ready to code like a superhero! Your LazyVim beast mode is fully activated! 🚀🔥

Happy coding, and may your bugs be few and your commits be clean! 🤠

My dotfiles configurations:

crafts69guy / .dotfiles

This repo leverages GNU Stow to simplify symlink management, making it easy to install and update configurations across different machines.

Warning: Don’t blindly use my settings unless you know what that entails. Use at your own risk!

📌 Contents

Neovim – Custom plugins, keybindings, and themes (LazyVim)
Tmux – Optimized terminal workflow
Git – Configuration for efficient version control
Karabiner – Custom key mappings with Fn (Hyper) key
Fish Shell – Enhanced terminal experience with Tide prompt
FZF – Fuzzy finder with fd, ripgrep, bat integration
GNU Stow – Simple dotfiles management

🚀 Setting Up a New Machine with This Repo

This repository uses GNU Stow to manage dotfiles efficiently with symlinks. Follow these steps to set up your new machine:

1. Install Required Packages

Install Stow & Essential Tools

macOS:

brew install stow git fish tmux neovim fd ripgrep bat eza fzf

Linux (Debian/Ubuntu):

sudo apt update && sudo apt install stow git fish tmux neovim

Linux (Arch):

sudo pacman -S stow git fish tmux neovim

Install Fisher

…

Crafts 69 GuyFollow

Web Developer 🧑‍💻

Why JSON-Serializable Rules Changed Everything: From Code Chaos to Configuration Clarity

Crafts 69 Guy — Sun, 24 Aug 2025 03:18:22 +0000

The Friday Afternoon Nightmare

It's 4 PM on Friday. Marketing just called: "We need to change the Black Friday discount rules before Monday." Your heart sinks. That's 500 lines of nested if-statements scattered across three microservices. You know what's coming: emergency deployment, weekend testing, and prayers that nothing breaks in production.

Sound familiar? This is the reality for countless development teams. Every business rule change means touching code, running through CI/CD pipelines, and risking production stability. A simple percentage adjustment becomes a full engineering operation.

But here's the question that changed everything for me: What if business rules were just... data?

The Core Insight: Rules ARE Data

Let me show you the transformation that made our business team cry tears of joy.

The Traditional Approach (Code-Coupled)

// Hidden in your codebase, deployed with your app
function applyDiscountRules(customer, cart, inventory) {
  if (customer.tier === 'gold' && customer.purchases > 5000) {
    if (cart.total > 100 && inventory.stock < 10) {
      applyDiscount(0.2);
    } else if (cart.total > 500) {
      applyDiscount(0.15);
    }
  } else if (customer.tier === 'silver') {
    // ... 50 more lines of conditions
  }
  // ... continues for 500+ lines
}

This code is familiar, but it's also a prison. Every change requires a developer, a pull request, code review, testing, and deployment. Your business logic is literally compiled into your application.

The JSON-Serializable Approach (Data-Driven)

{
  "name": "premium_customer_scarce_inventory_discount",
  "version": "2.1",
  "rule": {
    "and": [
      { "eq": ["customer.tier", "gold"] },
      { "gt": ["customer.purchases", 5000] },
      { "gt": ["cart.total", 100] },
      { "lt": ["inventory.stock", 10] }
    ]
  },
  "action": { "discount": 0.2 }
}

This isn't just cleaner—it's revolutionary. This rule is:

✅ Stored in a database, not your codebase
✅ Modified without deployment—update and save
✅ Versioned like any other data—full audit trail
✅ Shared across any system that reads JSON

The best part? Your entire application integration becomes one line:

const decision = ruleEngine.evaluateExpr(rule, customerData);

The Three Game-Changing Benefits

1. Real-Time Business Agility

Remember that Friday afternoon nightmare? Here's how it plays out now:

Before: "We'll need 2 sprints to implement that promotion logic. Can we push this to Q2?"

After: "Give me 5 minutes to update the rule in the database. Done. It's live."

Let me share a real example. Our e-commerce team wanted to run a flash sale targeting customers who abandoned carts over $200 in the last 24 hours. Previously, this would've been a two-week project. With JSON rules, our marketing manager created this herself:

{
  "flash_sale_recovery": {
    "and": [
      { "gt": ["cart.abandonedValue", 200] },
      { "lt": ["cart.abandonedHours", 24] },
      { "eq": ["customer.hasActivePromo", false] }
    ]
  }
}

Time from idea to live: 12 minutes.

The impact? Our marketing team now launches 10x more targeted campaigns because they don't need to wait for engineering resources. They experiment, iterate, and optimize in real-time. When a campaign isn't working, they adjust it immediately—no JIRA tickets, no sprint planning, no deployments.

2. Universal Portability

Here's where JSON rules become truly powerful. The same rule works everywhere:

{
  "fraud_check": {
    "or": [
      { "gt": ["transaction.amount", "user.dailyLimit"] },
      { "gt": ["transaction.riskScore", 0.8] },
      { "eq": ["transaction.country", "high_risk_list"] }
    ]
  }
}

This single rule definition can be:

Evaluated in your React app for instant user feedback
Enforced by your Node.js API for transaction processing
Applied in your Python batch job for historical analysis
Cached in your mobile app for offline validation

No translation, no duplication, no synchronization headaches. One rule, infinite implementations.

We learned this the hard way when our mobile app's validation logic diverged from our backend. Users saw "valid" in the app but got errors on submission. Now? Both use the exact same JSON rule fetched from our API. Perfect consistency, zero maintenance.

3. Built-in Audit & Compliance

Last year, regulators asked us: "Show us the exact fraud detection rules that were active on October 1st, 2023, at 3:47 PM."

With hardcoded rules, this would've meant git archaeology, deployment logs, and prayers that we could reconstruct the exact state. With JSON rules stored in our database:

SELECT rule_definition, version, modified_by, modified_at 
FROM business_rules 
WHERE rule_type = 'fraud_detection' 
  AND effective_date <= '2023-10-01 15:47:00'
  AND (expired_date IS NULL OR expired_date > '2023-10-01 15:47:00');

Five seconds later, we had a complete audit trail:

{
  "id": "rule_fraud_vel_423",
  "version": 3,
  "modified_by": "jane.doe@company.com",
  "modified_at": "2023-09-28T10:30:00Z",
  "approved_by": "john.smith@company.com",
  "rule_definition": { /* complete rule */ }
}

The auditors were speechless. What usually takes weeks of documentation took us minutes.

Live Demo: Dynamic Pricing Engine

Let me show you the power of JSON rules with a real-world scenario that every marketplace faces: dynamic pricing based on supply, demand, and customer segments.

Step 1: Define the Rule

Your business team wants surge pricing when inventory is low, demand is high, and the customer is an early adopter. Here's the rule:

{
  "dynamic_pricing": {
    "and": [
      { "between": ["inventory.level", [1, 5]] },
      { "gt": ["product.viewsLastHour", 100] },
      { "contains": ["customer.segments", "early_adopter"] }
    ]
  }
}

Notice how readable this is? Your product manager can understand and even modify this without any coding knowledge.

Step 2: Evaluate in Real-Time

const context = {
  inventory: { level: 3 },
  product: { viewsLastHour: 150, basePrice: 99.99 },
  customer: { 
    segments: ["early_adopter", "premium"],
    id: "cust_123"
  }
};

const result = engine.evaluateExpr(pricingRule, context);
if (result.success) {
  // Apply 20% surge pricing
  const finalPrice = context.product.basePrice * 1.2;
}

Step 3: Modify Without Code

Your business team decides to add time-based conditions for happy hour. They simply update the JSON:

{
  "dynamic_pricing": {
    "and": [
      { "between": ["inventory.level", [1, 5]] },
      { "gt": ["product.viewsLastHour", 100] },
      { "contains": ["customer.segments", "early_adopter"] },
      { "not": [
        { "between": ["currentHour", [17, 19]] }  // Exclude happy hour
      ]}
    ]
  }
}

Zero code changes. Zero deployments. Instant effect.

The Magic: Field-to-Field Comparison

Here's the feature that makes developers gasp and business teams cheer:

{
  "smart_discount": {
    "and": [
      { "gt": ["user.loyaltyPoints", "product.pointsRequired"] },
      { "lte": ["user.currentMonthSpend", "user.monthlyBudget"] }
    ]
  }
}

You can compare any field to any other field dynamically. No more hardcoding relationships between data points. The business team can create sophisticated rules comparing user attributes to product attributes, temporal conditions to inventory levels, or any other combination—all without writing a single line of code.

Real Impact: The Numbers That Matter

Let me share the actual metrics from companies that have adopted JSON-serializable rules:

Development Velocity

Before: 3-5 days to implement new business rule (coding, testing, deployment)
After: 30 minutes from idea to production
Impact: 95% reduction in rule implementation time

Operational Risk

Before: Every rule change = deployment risk, potential downtime
After: Rule changes are data updates, zero deployment risk
Impact: 80% fewer production incidents related to business logic

Business Empowerment

Before: Business team → JIRA ticket → Engineering backlog → Wait 2 sprints
After: Business team → Rule UI → Save → Instant activation
Impact: 10x more experiments, 5x faster market response

Case Study: FinTech Loan Approval

A lending platform I worked with migrated 200+ loan approval rules to JSON. The results:

Deployment frequency: From weekly (for rule changes) to none
Rule update time: From 2 days to 5 minutes
Compliance audit preparation: From 2 weeks to 2 hours
New market entry: From 3 months to 2 weeks (just configure new rules)
Developer hours saved: 40 hours/month redirected to feature development

The CFO calculated the total impact: $1.2M saved annually from faster time-to-market and reduced operational overhead.

Quick Start: Your First Rule

Ready to try this yourself? Here's how to get started in less than 5 minutes:

Install

npm install rule-engine-js

Create Your First Rule

import { createRuleEngine, createRuleHelpers } from 'rule-engine-js';

// Use helpers for readable rule creation
const rules = createRuleHelpers();

// Build a VIP customer rule
const vipCustomerRule = rules.and(
  rules.gte('account.totalPurchases', 10000),
  rules.in('account.tier', ['gold', 'platinum']),
  rules.isNotNull('profile.verified')
);

// Evaluate against any data
const engine = createRuleEngine();
const customerData = {
  account: { 
    totalPurchases: 15000, 
    tier: 'gold' 
  },
  profile: { 
    verified: true 
  }
};

const result = engine.evaluateExpr(vipCustomerRule, customerData);
console.log(result.success ? 'VIP Customer!' : 'Regular Customer');

Store Your Rules Anywhere

PostgreSQL: Store in a jsonb column with versioning
MongoDB: Natural fit as documents
Redis: Cache rules for microsecond evaluation
S3: Version control with CloudFront distribution
API: Centralized configuration service

The beauty? Your rule engine doesn't care where rules come from. Fetch from database, API, or local file—it just works.

When to Use JSON-Serializable Rules

Perfect For:

✅ Fraud detection - Rules evolve daily as new patterns emerge
✅ Pricing/Promotions - Marketing teams get autonomy
✅ Access control - Complex permission logic without code changes
✅ Workflow routing - Dynamic decision trees that business owns
✅ Compliance checks - Auditable, versioned rule history

Not Ideal For:

❌ Simple, static conditions that never change
❌ Performance-critical hot paths (unless properly cached)
❌ Complex mathematical calculations (though you can add custom operators)

The Paradigm Shift

Here's the mindset change that transforms everything:

Stop thinking: "How do I code this business logic?"

Start thinking: "How do I configure this business logic?"

Your code becomes a stable engine that rarely changes. Your business rules become fluid data that adapts to market needs in real-time.

The ultimate test? Can your business team explain why a customer got a discount by looking at a JSON file? If yes, you've achieved true transparency. No more black box algorithms. No more "let me check the code." Just clear, readable, modifiable rules.

Take Action

The path forward is simple:

Today: Pick your most painful business rule—the one that changes monthly
Tomorrow: Implement it as JSON with the rule engine
Next Week: Show your team the difference in deployment metrics
Next Month: Watch your velocity metrics soar

Every hardcoded business rule is technical debt accumulating interest. Every JSON rule is a business asset that appreciates in value as your team learns to leverage it.

Your future is literally one line of code away:

const future = engine.evaluateExpr(jsonRule, reality);

The question isn't whether to adopt JSON-serializable rules. It's whether you'll do it before your competitors do.

Ready to transform your business logic? Check out the rule-engine-js repository, or dive into the documentation.

What's your worst business logic nightmare? Share your story in the comments—I'd love to hear how JSON rules could solve it.

5 Lines of Code That Will Make Your Business Logic Beautiful

Crafts 69 Guy — Tue, 19 Aug 2025 09:16:43 +0000

The Before/After That Will Blow Your Mind
We've All Been Here
The Magic Moment That Changed Everything
Try This Right Now (30 Seconds)
Three Superpowers That Will Change Your Life
- Superpower 1: Dynamic Field Comparison
- Superpower 2: Zero Dependencies + Lightning Fast
- Superpower 3: Production-Ready Security
Your Real-World Use Cases
- Form Validation That Doesn't Suck
- User Access Control (The Clean Way)
- Dynamic Pricing (Without The Headache)
Framework? We Don't Care About Your Framework
The Challenge: I Dare You To Try This
The Proof Is In The Pudding
Your Next 5 Minutes

The Before/After That Will Blow Your Mind 😶‍🌫️

// ❌ BEFORE: 100+ lines of spaghetti code nightmare
function canUserAccessResource(user, resource, order) {
  if (!user) return false;
  if (!user.active) return false;
  if (user.status === 'banned' || user.status === 'suspended') return false;
  if (!user.emailVerified) return false;

  if (user.age < 18) return false;
  if (user.role === 'admin') return true;

  if (user.role === 'user') {
    if (!user.permissions || !Array.isArray(user.permissions)) return false;
    if (!user.permissions.includes('read')) return false;

    if (resource.sensitivity === 'high') {
      if (!user.permissions.includes('sensitive_data')) return false;
      if (user.clearanceLevel < 3) return false;
    }

    if (order && order.total > 1000) {
      if (user.accountAge < 30) return false;
      if (!user.verifiedIdentity) return false;
    }

    if (user.department !== resource.department) {
      if (!user.crossDepartmentAccess) return false;
    }

    // ... 60+ more lines of nested conditions
  }

  return false;
}

// ✅ AFTER: 5 clean, readable lines with Rule Engine JS
const accessRule = rules.and(
  rules.validation.activeUser('user'),
  rules.gte('user.age', 18),
  rules.or(
    rules.eq('user.role', 'admin'),
    rules.and(
      rules.in('read', 'user.permissions'),
      rules.departmentAccess('user', 'resource')
    )
  )
);

const canAccess = engine.evaluate(accessRule, { user, resource, order });

What if I told you this messy business logic that's killing your codebase could be 5 readable lines instead?

We've All Been Here 🫂

Picture this: It's Friday afternoon. The product manager slides into your DMs with those dreaded words: "Hey, can you just add one tiny condition to the user access logic?"

You open the file. 200 lines of nested if statements stare back at you. Comments from 3 different developers. Business logic scattered across 7 different functions. You die a little inside.

Sound familiar? 😭

Every developer has that one function. You know the one:

Started as "simple user validation"
Now handles 47 different edge cases
Nobody wants to touch it
Breaks every time someone sneezes
Takes 30 minutes to understand what it actually does

The Magic Moment That Changed Everything

Here's what made me build Rule Engine JS. I was working on an e-commerce platform when the business team dropped this bomb:

"We need to update discount rules every week without deploying code."

That's when it hit me: What if business logic could live in the database as simple JSON?

// Store rules as JSON in your database
const discountRule = {
  "or": [
    {
      "and": [
        {"eq": ["customer.type", "vip"]},
        {"gte": ["order.total", 100]}
      ]
    },
    {"gte": ["customer.loyaltyPoints", 1000]},
    {
      "and": [
        {"eq": ["customer.isFirstTime", true]},
        {"gte": ["order.total", 50]}
      ]
    }
  ]
};

// Business team updates rules WITHOUT touching code
await updateRule('discount-eligibility', newRules);

// Your app instantly uses the new logic
const result = engine.evaluate(loadedRule, customerData);

Zero deployments. Zero downtime. Zero developer headaches.

Try This Right Now (30 Seconds)

npm install rule-engine-js

import { createRuleEngine, createRuleHelpers } from 'rule-engine-js';

const engine = createRuleEngine();
const rules = createRuleHelpers();

// Test it with the alcohol purchase rule
const canBuyAlcohol = rules.gte('age', 21);

console.log(engine.evaluate(canBuyAlcohol, { age: 25 })); // true
console.log(engine.evaluate(canBuyAlcohol, { age: 19 })); // false

// Your first "holy shit" moment starts now

That's it. No configuration. No setup. Just working code.

Three Superpowers That Will Change Your Life

🔥 Superpower 1: Dynamic Field Comparison

Most rule engines make you jump through hoops to compare fields. We make it natural:

// Compare ANY fields in your data
const orderValidation = rules.and(
  rules.field.lessThan('order.total', 'user.creditLimit'),
  rules.field.equals('password', 'confirmPassword'),
  rules.field.greaterThan('user.accountAge', 'security.minimumAge')
);

// Works with nested objects automatically
const profileCheck = rules.field.equals('user.email', 'backup.recoveryEmail');

Other rule engines: "Write custom validators and hope they work"

Rule Engine JS: "Just tell us what to compare"

⚡ Superpower 2: Zero Dependencies + Lightning Fast

// Bundle size: 24KB (smaller than most images)
// Evaluation time: <1ms (faster than a database query)
// Dependencies: 0 (your security team will love you)
// Node.js versions: 16+ (just works everywhere)

Your app stays lean. Your builds stay fast. Your deploys stay simple.

🛡️ Superpower 3: Production-Ready Security

We handle the nightmare scenarios so you don't have to:

// Built-in protection against:
// ✅ Prototype pollution attacks
// ✅ Code injection attempts  
// ✅ DoS attacks via complex rules
// ✅ Function execution exploits

// This malicious input fails safely:
const maliciousData = {
  __proto__: { isAdmin: true },
  constructor: { prototype: { hasAccess: true } }
};

engine.evaluate(rule, maliciousData); // Secure, no exploits possible

Sleep better knowing your rule engine isn't a security hole.

Your Real-World Use Cases

Form Validation That Doesn't Suck

const formRules = rules.and(
  rules.validation.required('email'),
  rules.validation.email('email'),
  rules.field.equals('password', 'confirmPassword'),
  rules.validation.ageRange('age', 18, 120),
  rules.isTrue('agreedToTerms')
);

// One rule handles your entire form
const isValid = engine.evaluate(formRules, formData);

User Access Control (The Clean Way)

const accessRule = rules.and(
  rules.isTrue('user.active'),
  rules.or(
    rules.eq('user.role', 'admin'),
    rules.and(
      rules.eq('user.department', 'resource.department'),
      rules.in('read', 'user.permissions')
    )
  )
);

// Express middleware in 3 lines
app.get('/sensitive-data', (req, res, next) => {
  const hasAccess = engine.evaluate(accessRule, { user: req.user, resource });
  hasAccess ? next() : res.status(403).json({ error: 'Access denied' });
});

Dynamic Pricing (Without The Headache)

const pricingRule = rules.or(
  // VIP discount
  rules.and(
    rules.eq('customer.tier', 'vip'),
    rules.gte('order.total', 100)
  ),
  // Loyalty discount  
  rules.gte('customer.points', 1000),
  // First-time customer
  rules.and(
    rules.isTrue('customer.firstTime'),
    rules.gte('order.total', 50)
  )
);

// Business team updates pricing rules via admin panel
// Zero developer involvement

Framework? We Don't Care About Your Framework

React? ✅ Perfect

Vue? ✅ Works great

Express? ✅ Love it

Next.js? ✅ No problem

Vanilla JS? ✅ Obviously

Your weird internal framework? ✅ Probably fine

// React component
function UserProfile({ user }) {
  const canEdit = engine.evaluate(editRule, { user, currentUser });
  return (
    <div>
      <h1>{user.name}</h1>
      {canEdit && <button>Edit Profile</button>}
    </div>
  );
}

// Vue computed property
computed: {
  userCanAccess() {
    return engine.evaluate(this.accessRule, this.userData);
  }
}

// Express middleware
const checkAccess = (rule) => (req, res, next) => {
  engine.evaluate(rule, req.user) ? next() : res.status(403).end();
};

The Challenge: I Dare You To Try This

Here's my challenge: Take your messiest business logic function. The one that makes junior developers cry. The one with 47 nested conditions.

Time yourself:

⏱️ 5 minutes to install Rule Engine JS
⏱️ 10 minutes to rewrite that function as rules
⏱️ Watch your code become readable for the first time in months

I bet you'll:

Cut your code by 60-80%
Actually understand what the logic does
Want to rewrite every other business rule in your app
Wonder why you didn't do this years ago

The Proof Is In The Pudding

// Before: 47 lines, 6 nested levels, 3 bugs, 0 tests
function canUserDoThing(user, thing, context) {
  // ... 47 lines of hell
}

// After: 8 lines, readable, testable, maintainable
const canDoThingRule = rules.and(
  rules.validation.activeUser('user'),
  rules.or(
    rules.eq('user.role', 'admin'),
    rules.and(
      rules.in('thing.permission', 'user.permissions'),
      rules.field.greaterThan('user.level', 'thing.requiredLevel')
    )
  )
);

const result = engine.evaluate(canDoThingRule, { user, thing, context });

Same logic. 85% less code. 100% more sanity.

Your Next 5 Minutes

Ready to stop hating your business logic?

⭐ Star the repo: github.com/crafts69guy/rule-engine-js (seriously, this helps)

🚀 Try it now: npm install rule-engine-js

📚 Read the docs: Complete examples and patterns included

💬 Tell me your story: What business logic nightmare did you solve? I want to hear about your wins!

🐛 Found an issue? Open a GitHub issue - I actually respond to them

Built by a developer who was tired of business logic spaghetti. Zero dependencies, maximum developer happiness.

P.S. - If you're still writing 100-line business logic functions in 2024, your future self will thank you for making the switch. Trust me on this one.

Stop Hardcoding Business Logic: Meet Rule Engine JS

Crafts 69 Guy — Mon, 18 Aug 2025 03:48:23 +0000

The Problem That Started It All
Enter Rule Engine JS
- Zero Dependencies, Maximum Performance
- Developer Experience That Actually Makes Sense
- Dynamic Field Comparison (The Game Changer)
Real-World Examples
- Form Validation Made Simple
- User Access Control
Built for Production
- Performance That Scales
- Security First
- Monitoring Included
Framework Agnostic
Getting Started (30 Seconds)
Why I Think You'll Love It
What's Next?

Have you ever found yourself buried in nested if-else statements, trying to implement complex business rules that change every other week? Or worse, watched your clean codebase turn into a maintenance nightmare because business logic was scattered across dozens of files?

I've been there. And that's exactly why I built Rule Engine JS.

The Problem That Started It All

Picture this: You're building an e-commerce platform, and the business team comes to you with "simple" requirements:

VIP customers get discounts on orders over $100
Regular customers need 1000+ loyalty points for discounts
First-time customers get 20% off orders over $50
But only during business hours
Unless it's a weekend
Or a holiday
And the rules change next month...

Sound familiar? 😅

The real kicker came when they said: "Oh, and we need to store these rules in the database so we can update them without deploying."

That's when I realized I needed something that could handle JSON-serializable business logic without sacrificing developer experience or performance.

Enter Rule Engine JS

After trying existing solutions and finding them either too complex, too slow, or lacking key features, I decided to build something better. Here's what makes Rule Engine JS different:

🚀 Zero Dependencies, Maximum Performance

No bloated dependency trees. No security vulnerabilities from third-party packages. Just clean, efficient JavaScript that works everywhere:

import { createRuleEngine, createRuleHelpers } from 'rule-engine-js';

const engine = createRuleEngine();
const rules = createRuleHelpers();

// That's it. You're ready to go.

🎯 Developer Experience That Actually Makes Sense

Remember those nested JSON rules that make your eyes bleed? Not here:

// Instead of this nightmare:
const rule = {
  "and": [
    { "gte": ["user.age", 18] },
    { "eq": ["user.status", "active"] },
    { "in": ["write", "user.permissions"] }
  ]
}

// Write this:
const rule = rules.and(
  rules.gte('user.age', 18),
  rules.eq('user.status', 'active'),
  rules.in('write', 'user.permissions')
);

Both compile to the same JSON (perfect for database storage), but only one is actually maintainable.

Dynamic Field Comparison (The Game Changer)

Here's where things get interesting. Need to compare fields within your data? Most rule engines make you jump through hoops. Rule Engine JS makes it natural:

const orderValidation = rules.and(
  rules.field.lessThan('order.total', 'user.creditLimit'),
  rules.field.equals('order.currency', 'user.preferredCurrency'),
  rules.gte('user.accountAge', 30) // days
);

This was the feature I desperately needed for my original project - and now it's built right in.

Real World Examples

Let's solve that e-commerce discount problem from earlier:

const discountEligibility = rules.or(
  // VIP customers with minimum order
  rules.and(
    rules.eq('customer.type', 'vip'),
    rules.gte('order.total', 100)
  ),

  // High loyalty points
  rules.gte('customer.loyaltyPoints', 1000),

  // First-time customer bonus
  rules.and(
    rules.isTrue('customer.isFirstTime'),
    rules.gte('order.total', 50)
  )
);

// Later, when business rules change:
const updatedRules = await database.getRules('discount-eligibility');
const result = engine.evaluateExpr(updatedRules, customerData);

No deployments. No code changes. Just update the database and you're done.

Form Validation Made Simple

const formValidation = rules.and(
  rules.validation.required('email'),
  rules.validation.email('email'),
  rules.field.equals('password', 'confirmPassword'),
  rules.validation.ageRange('age', 18, 120),
  rules.isTrue('agreedToTerms')
);

// Returns detailed validation results
const result = engine.evaluateExpr(formValidation, formData);
if (!result.success) {
  console.log('Validation failed:', result.error);
}

User Access Control

const accessRule = rules.and(
  rules.isTrue('user.isActive'),
  rules.or(
    rules.eq('user.role', 'admin'),
    rules.and(
      rules.eq('user.department', 'resource.department'),
      rules.in('read', 'user.permissions')
    )
  )
);

// Perfect for middleware
app.get('/api/sensitive-data', (req, res, next) => {
  const hasAccess = engine.evaluateExpr(accessRule, {
    user: req.user,
    resource: { department: 'finance' }
  });

  hasAccess.success ? next() : res.status(403).json({ error: 'Access denied' });
});

Built for Production

Performance That Scales

Intelligent LRU caching for repeated evaluations
Path resolution caching for nested object access
Regex pattern caching for validation rules
Typically under 1ms evaluation time

Security First

Built-in protection against prototype pollution
Safe path resolution (no function execution)
Input validation and sanitization
Configurable complexity limits to prevent DoS

Monitoring Included

// Built-in performance metrics
const metrics = engine.getMetrics();
console.log({
  evaluations: metrics.evaluations,
  cacheHitRate: metrics.cacheHits / metrics.evaluations,
  averageTime: metrics.avgTime + 'ms'
});

Framework Agnostic

Whether you're using React, Vue, Express, Next.js, or vanilla JavaScript - Rule Engine JS just works:

// React
function useRuleValidation(rules, data) {
  return useMemo(() => 
    engine.evaluateExpr(rules, data), [rules, data]
  );
}

// Express middleware
const createAccessMiddleware = (rule) => (req, res, next) => {
  const result = engine.evaluateExpr(rule, req.user);
  result.success ? next() : res.status(403).end();
};

// Vue computed property
computed: {
  isEligible() {
    return engine.evaluateExpr(this.businessRules, this.userData).success;
  }
}

Getting Started (30 Seconds)

npm install rule-engine-js

import { createRuleEngine, createRuleHelpers } from 'rule-engine-js';

const engine = createRuleEngine();
const rules = createRuleHelpers();

// Your first rule
const canAccess = rules.and(
  rules.gte('user.age', 18),
  rules.eq('user.status', 'active')
);

// Test it
const result = engine.evaluateExpr(canAccess, {
  user: { age: 25, status: 'active' }
});

console.log(result.success); // true

That's it. No configuration files, no complex setup - just clean, working code.

Why I Think You'll Love It

After using Rule Engine JS in production for several months, here's what I appreciate most:

It stays out of your way - Simple API, predictable behavior
Debugging is actually pleasant - Clear error messages and built-in logging
Performance is transparent - See exactly how your rules are performing
Security is handled - Protection against common attacks built-in
It scales with your needs - From simple validation to complex business logic

What's Next?

I'm actively working on Rule Engine JS and would love your feedback. Whether you're dealing with complex business rules, form validation, or access control - give it a try and let me know what you think.

⭐ Star the repo: github.com/crafts69guy/rule-engine-js

📦 Try it now: npm install rule-engine-js

📚 Full docs: Comprehensive guides and examples included

🐛 Issues: Found a bug or have a feature request? I'd love to hear from you!

Rule Engine JS is MIT licensed and has zero dependencies. It works in Node.js 16+ and all modern browsers. Built by developers, for developers who are tired of hardcoding business logic.

How to Manage Your Dotfiles Like a Pro with Git and Stow

Crafts 69 Guy — Wed, 26 Feb 2025 11:13:04 +0000

Have You Ever Managed Your Dotfiles? 🤔

If you’re a developer, chances are you’ve customized your environment—tweaking your .config, .bashrc, .czrc, .zshrc, .vimrc, or .tmux.conf to fit your workflow. But have you ever switched machines and realized you forgot to back them up? Or worse, you messed up your config and wished you had version control?

That’s where dotfile management comes in. Instead of manually copying files, let’s explore how to use Git to store them—and how GNU Stow can make managing them effortless. 🚀

My dotfiles configurations:

crafts69guy / .dotfiles

This repo leverages GNU Stow to simplify symlink management, making it easy to install and update configurations across different machines.

Warning: Don’t blindly use my settings unless you know what that entails. Use at your own risk!

📌 Contents

Neovim – Custom plugins, keybindings, and themes
Tmux – Optimized terminal workflow
Git – Configuration for efficient version control
Karabiner – Custom key mappings for Vim efficiency
Fish Shell – Enhanced terminal experience
GNU Stow – Simple dotfiles management

🚀 Setting Up a New Machine with This Repo

This repository uses GNU Stow to manage dotfiles efficiently with symlinks. Follow these steps to set up your new machine:

1. Install Required Packages

Install Stow & Essential Tools

macOS:

brew install stow git fish tmux neovim

Linux (Debian/Ubuntu):

sudo apt update && sudo apt install stow git fish tmux neovim

Linux (Arch):

sudo pacman -S stow git fish tmux neovim

Install Fisher

A plugin manager for Fish
macOS:

curl -sL https://raw.githubusercontent.com/jorgebucaran/fisher/main/functions/fisher.fish | source && fisher install jorgebucaran/fisher

Install Tide after installed

…

Installing Stow 🛠️

Before we dive into using Stow, let's install it on your system.

On macOS (using Homebrew):

brew install stow

On Debian/Ubuntu:

sudo apt update && sudo apt install stow -y

On Arch Linux:

sudo pacman -S stow

Once installed, you can verify the installation by running:

stow --version

The Old-School Way: Manual Syncing with Git 📂

Before discovering Stow, I used to manage my dotfiles like this:

Copy the dotfiles to a dedicated folder:

   mkdir -p ~/.dotfiles
   cp -r -f -v ~/.config ~/.dotfiles/.config
   cp -r -f -v ~/.zshrc ~/.dotfiles/.zshrc
   ...

Initialize a Git repository and push to GitHub:

   cd ~/.dotfiles
   git init
   git add .
   git commit -m "Initial commit"
   git remote add origin git@github.com:yourusername/.dotfiles.git
   git push -u origin main

Manually restore dotfiles when needed:

   cp -r -f -v ~/.dotfiles/.config ~/.config
   cp -r -f -v ~/.dotfiles/.zshrc ~/.zshrc

This worked, but it was tedious. Every time I updated my dotfiles, I had to manually copy them back and forth. There had to be a better way—and that’s when I found GNU Stow. 🎉

Meet Stow: A Simple Yet Powerful Tool for Dotfiles 🛠️

GNU Stow is a symlink farm manager that helps manage the installation of software packages by creating symbolic links (symlinks) in a structured way.

It allows users to keep software files organized in a single directory (source) and symlink them into another location (target) without directly copying or modifying the files.
It was originally designed for managing software packages, but it’s perfect for handling dotfiles.

How Stow Works

Instead of copying files, Stow creates symbolic links from a central directory (like ~/.dotfiles) to their actual locations (like ~/.config).
This means you only need to track files in one place, and Stow takes care of placing them in the right locations.

Concept	Explanation	Example (macOS)
package_name	The folder that contains the files you want to symlink (e.g., a software package or configuration files).	A directory named `vim` that contains configuration files for Vim.
Source Directory	The location where packages are stored before being linked.	`~/.dotfiles/` is the source directory where `vim`, `git`, and `tmux` configurations are stored.
Target Directory	The location where symlinks will be created, pointing to files in the package.	`~/.config/` is the target directory where the actual symlinks will be placed.

GNU Stow cheat sheet

Example of Stow in Action 🔗

Imagine your dotfiles are structured like this:

~/.dotfiles/
├── nvim/
│   ├── .config/nvim/init.lua
├── tmux/
│   ├── .tmux.conf
├── zshrc/
│   ├── .zshrc

Instead of manually copying them, you can simply run:

stow -d ~/.dotfiles -t ~ nvim
stow -d ~/.dotfiles -t ~ tmux
stow -d ~/.dotfiles -t ~ zshrc

Let's break it down:

stow: The command to run GNU Stow.
-d ~/.dotfiles: Specifies the source directory where the dotfiles are stored (~/.dotfiles). Stow assumes that inside this directory, there are subdirectories for different applications (e.g., nvim, zsh, etc.).
-t ~: Sets the target directory (~, which is your home directory). Stow will create symlinks in this directory.
nvim: The subdirectory inside ~/.dotfiles that contains the actual configuration files for Neovim. Stow will take the files inside ~/.dotfiles/nvim and symlink them into your home directory.

This creates symlinks:

~/.config/nvim/init.lua → ~/.dotfiles/nvim/.config/nvim/init.lua
~/.tmux.conf → ~/.dotfiles/tmux/.tmux.conf
~/.zshrc → ~/.dotfiles/zshrc/.zshrc

Alternatively, you can use:

cd ~/.dotfiles
stow -v .

This applies symlinks for all directories inside .dotfiles. The -v flag gives verbose output, so you can see what Stow is doing.

[!WARNING]
When using stow -v . a little different.

What It Does:

-v → Enables verbose mode, showing which symlinks are created.

. → Assumes you are inside ~/.dotfiles and applies stow to all directories inside it.

and the output should creates symlinks become:
~/nvim/.config/nvim/init.lua  →  ~/.dotfiles/nvim/.config/nvim/init.lua
~/tmux/.tmux.conf → ~/.dotfiles/tmux/.tmux.conf
~/zshrc/.zshrc                 →  ~/.dotfiles/zshrc/.zshrc

To remove symlinks, you can run:

stow -D tmux

To restow (apply changes after updating dotfiles):

stow -R tmux

How to Manage Dotfiles with Stow and Git (Step by Step) 📌

Here’s a simple workflow to manage dotfiles with Stow and Git:

1. Create a `dotfiles` Directory

mkdir -p ~/.dotfiles
cd ~/.dotfiles

2. Organize Your Dotfiles

Let's move all dotfiles you want to stow and manage.

mv -f ~/.config ~/.dotfiles/.config
mv -f ~/.tmux.conf ~/.dotfiles/.tmux.conf
mv -f ~/.zshrc ~/.dotfiles/.zshrc

3. Use Stow to Create Symlinks

Apply all dotfiles at once:

stow -v .

Awesome 🤠

4. Initialize a Git Repository and Push to GitHub

cd ~/.dotfiles
git init

git add .
git commit -m "Initial dotfiles setup"
git remote add origin git@github.com:yourusername/.dotfiles.git
git push -u origin main

5. Restore Dotfiles on a New Machine 🖥️

When setting up a new machine, simply clone the repo and re-run Stow:

git clone git@github.com:yourusername/.dotfiles.git ~/.dotfiles
cd ~/.dotfiles
stow -v .

That’s it! No more copying files manually. 🚀

Note: make sure stow installed.

Ignoring Files with `stow-local-ignore` 📜

Sometimes, you may want Stow to ignore specific files or directories within your dotfiles setup. For this, you can use a .stow-local-ignore file inside the respective package directory.

How to Use `.stow-local-ignore`

Create a .stow-local-ignore file inside the package directory:

   touch ~/.dotfiles/.stow-local-ignore

Add the names of files or directories you want Stow to ignore:

   .DS_Store
   .gitconfig
   .git
   .gitignore

   backup/
   tmp_config.json

Now, when running Stow, these files will be skipped while symlinking.

This is useful for keeping temporary or machine-specific files out of your Stow-managed dotfiles!

Bonus: Ignore Unwanted Files 🛑

To avoid pushing unnecessary files, create a .gitignore:

# Ignore system-specific files
.history
.local
.cache

This keeps your repo clean and portable.

Conclusion 🎯

Managing dotfiles manually is painful, but with Git and Stow, you can:

✔ Keep all your configurations versioned and backed up.\
✔ Easily sync dotfiles across machines.\
✔ Avoid cluttering your home directory with redundant copies.

Try setting up Stow today—it might just change the way you manage your development environment forever! 💡

Do you have a favorite dotfile management trick? Share your thoughts in the comments! 💬

Crafts 69 GuyFollow

Web Developer 🧑‍💻

See you soon.

Thanks for reading!

Customizing Your Lazyvim Setup for Personal Preferences (Part 2)

Crafts 69 Guy — Sun, 30 Jun 2024 16:03:02 +0000

Folder Structure Tree of LazyVim
Overview of the bullet points
- Solarized Osaka theme
- Key Mappings
- Auto Commands
- Options Configuration Vim

Welcome back, my friends!

I know, I know, it's been a while since we last delved into the wonderful world of LazyVim customization.

In Part 1, we laid the groundwork with LazyVim, establishing a solid foundation for our Neovim journey. Now, it's time to take things to the next level – personalization!

In the next section, I want to express my gratitude to Takuya Matsuyama, who is a true inspiration to me. I have learned a great deal from his work, and I am deeply appreciative of his contributions to the field.

And now, let's start cowboy 🤠🤠🤠.

Folder Structure Tree of LazyVim

Before starting to customize anything, we need to quickly look through the default File Structure Diagram of Lazy.vim to get an overview of it.
For more information: General Settings

~/.config/nvim
├── lua
│   ├── config
│   │   ├── autocmds.lua
│   │   ├── keymaps.lua
│   │   ├── lazy.lua
│   │   └── options.lua
│   └── plugins
│       ├── spec1.lua
│       ├── **
│       └── spec2.lua
└── init.toml

autocmds.lua (auto commands): are used to automatically execute specific commands or functions in response to certain events in the editors.

Greatly enhance your Vim workflow, it very wonderful 😍.

keymaps (key mappings): are configurations that define custom keyboard shortcuts. These mappings allow users to bind specific keys or combinations of keys to Vim commands, functions, or scripts, … thereby streamlining their workflow and making repetitive tasks quicker and easier.

Suppose you don’t know about Key Mappings. In that case, I think this is a useful blog to get started with: Basic Vim Mapping.
Thanks for the great post!

Igor IriantoFollow

Vim, Rails, cheesy puns

lazy.lua: this is a place to set the default configuration of the Lazy.vim
options.lua (optional): you can set anything to custom your Vim if you want like: autoindent, smartindent, hlsearch, showcmd, shiftwidth, … I will show my config later 🫣

Overview of the bullet points

Now, we are an overview of the bullet points I will configure in the next section:

Theme:
- Solarized Osaka (I’m a big fan of Takuya Matsuyama)
Keymaps:
- keymaps
- autocmds
- options
Plugins:
- ColorScheme (at above):
  - craftzdog/solarized-osaka.nvim
- coding:
  - smjonas/inc-rename.nvim
  - ThePrimeagen/refactoring.nvim (The Refactoring library based off the Refactoring book by Martin Fowler)
  - echasnovski/mini.bracketed
  - monaqa/dial.nvim
  - danymat/neogen
  - simrat39/symbols-outline.nvim (A tree like view for symbols in Neovim using the Language Server Protocol. Supports all your favourite languages.)
  - nvim-cmp (A completion engine plugin for neovim written in Lua. Completion sources are installed from external repositories and "sourced".)
  - kylechui/nvim-surround (Surround selections, stylishly 😎)
- lsp:
  - neovim/nvim-lspconfig
  - williamboman/mason.nvim (Portable package manager for Neovim that runs everywhere Neovim runs. Easily install and manage LSP servers, DAP servers, linters, and formatters.)
- treesitters:
  - nvim-treesitter/nvim-treesitter (to provide a simple and easy way to use the interface for tree-sitter in Neovim and to provide some basic functionality such as highlighting based on it)
  - nvim-treesitter/playground (View treesitter information directly in Neovim!)
  - nvim-treesitter/nvim-treesitter-context
- ui:
  - lukas-reineke/indent-blankline.nvim
  - folke/noice.nvim (Noice improves the UI for messages, cmdline and the popupmenu.)
  - rcarriga/nvim-notify (A fancy, configurable, notification manager for NeoVim)
  - echasnovski/mini.animate (has an extra that enables animations)
  - b0o/incline.nvim (When editing many files in a single tabpage, you can't quickly know which file is opened in the tabpage. That's because lualine's globalstatus option is set to false in LazyVim.)
  - folke/zen-mode.nvim
  - nvimdev/dashboard-nvim
- editors:
  - folke/flash.nvim
  - echasnovski/mini.hipatterns
  - dinhhuy258/git.nvim
  - telescope.nvim (It is an extendable _fuzzy finder _over lists.)

As you configure each plugin, it's a good idea to save your changes and restart nvim quickly. This helps you catch any errors right away and makes troubleshooting smoother down the line. Think of it like a mini test drive after each tweak! 🤠🤠🤠

Solarized Osaka theme:

To change your theme create a file like colorscheme.lua
Create: lua/plugins/colorscheme.lua and config:

return {
  {
    "craftzdog/solarized-osaka.nvim",
    branch = "osaka",
    lazy = true,
    priority = 1000,
    opts = function()
      return {
        transparent = true,
      }
    end,
  },
}

After config, you restart and see the theme:

Awesome 🥸🥸🥸!!!

Key Mappings

The LazyVim has already configured many things for me now, but I added some customizations like those in the file: lua/config/keymaps.lua

local keymap = vim.keymap
local opts = { noremap = true, silent = true }

keymap.set("n", "x", '"_x')

-- Increment/decrement
keymap.set("n", "+", "<C-a>")
keymap.set("n", "-", "<C-x>")

-- Delete a word backwards
keymap.set("n", "dw", 'vb"_d')

-- Select all
keymap.set("n", "<C-a>", "gg<S-v>G")

-- Save with root permission (not working for now)
--vim.api.nvim_create_user_command('W', 'w !sudo tee > /dev/null %', {})

-- Disable continuations
keymap.set("n", "<Leader>o", "o<Esc>^Da", opts)
keymap.set("n", "<Leader>O", "O<Esc>^Da", opts)

-- Jumplist
keymap.set("n", "<C-m>", "<C-i>", opts)

-- New tab
keymap.set("n", "te", ":tabedit")
keymap.set("n", "<tab>", ":tabnext<Return>", opts)
keymap.set("n", "<s-tab>", ":tabprev<Return>", opts)
-- Split window
keymap.set("n", "ss", ":split<Return>", opts)
keymap.set("n", "sv", ":vsplit<Return>", opts)
-- Move window
keymap.set("n", "sh", "<C-w>h")
keymap.set("n", "sk", "<C-w>k")
keymap.set("n", "sj", "<C-w>j")
keymap.set("n", "sl", "<C-w>l")

-- Resize window
keymap.set("n", "<C-w><left>", "<C-w><")
keymap.set("n", "<C-w><right>", "<C-w>>")
keymap.set("n", "<C-w><up>", "<C-w>+")
keymap.set("n", "<C-w><down>", "<C-w>-")

-- Pick a buffer
keymap.set("n", "<Leader>1", "<Cmd>BufferLineGoToBuffer 1<CR>", {})
keymap.set("n", "<Leader>2", "<Cmd>BufferLineGoToBuffer 2<CR>", {})
keymap.set("n", "<Leader>3", "<Cmd>BufferLineGoToBuffer 3<CR>", {})
keymap.set("n", "<Leader>4", "<Cmd>BufferLineGoToBuffer 4<CR>", {})
keymap.set("n", "<Leader>5", "<Cmd>BufferLineGoToBuffer 5<CR>", {})
keymap.set("n", "<Leader>6", "<Cmd>BufferLineGoToBuffer 6<CR>", {})
keymap.set("n", "<Leader>9", "<Cmd>BufferLineGoToBuffer -1<CR>", {})

-- Moving text
-- Move text up and down
keymap.set("n", "<C-Down>", "<Esc>:m .+1<CR>", opts)
keymap.set("n", "<C-Up>", "<Esc>:m .-2<CR>", opts)
keymap.set("v", "<C-Down>", ":m .+1<CR>", opts)
keymap.set("v", "<C-Up>", ":m .-2<CR>", opts)
keymap.set("x", "<C-Down>", ":move '>+1<CR>gv-gv", opts)
keymap.set("x", "<C-Up>", ":move '<-2<CR>gv-gv", opts)

-- Diagnostics
keymap.set("n", "<C-j>", function()
    vim.diagnostic.goto_next()
end, opts)

Auto Commands

lua/config/autocmds.lua

I don’t want to show concealing when using json and markdown files and turn off paste mode when leaving insert. So, I set conceallevel to 0 for json files and turned off paste mode like below.

If you want to use them, you can skip this config file 🙄

-- Turn off paste mode when leaving insert
vim.api.nvim_create_autocmd("InsertLeave", {
  pattern = "*",
  command = "set nopaste",
})

-- Disable the concealing in some file formats
-- The default conceallevel is 3 in LazyVim
vim.api.nvim_create_autocmd("FileType", {
  pattern = { "json", "jsonc", "markdown" },
  callback = function()
    vim.opt.conceallevel = 0
  end,
})

Awesome 🥸🥸🥸!!!

Options Configuration Vim

I have some config for default Vim, it’s only just an old config for normal nvim in the past: lua/config/options.lua. I will omit to explain this file 🫣

vim.g.mapleader = " "

vim.opt.encoding = "utf-8"
vim.opt.fileencoding = "utf-8"

vim.opt.spell = true
vim.opt.spelllang = { "en_us" }

vim.opt.number = true

vim.opt.title = true
vim.opt.autoindent = true
vim.opt.smartindent = true
vim.opt.hlsearch = true
vim.opt.backup = false
vim.opt.showcmd = true
vim.opt.cmdheight = 1
vim.opt.laststatus = 2
vim.opt.expandtab = true
vim.opt.scrolloff = 10
vim.opt.shell = "fish"
vim.opt.backupskip = { "/tmp/*", "/private/tmp/*" }
vim.opt.inccommand = "split"
vim.opt.ignorecase = true -- Case insensitive searching UNLESS /C or capital in search
vim.opt.smarttab = true
vim.opt.breakindent = true
vim.opt.shiftwidth = 2
vim.opt.tabstop = 2
vim.opt.wrap = false -- No Wrap lines
vim.opt.backspace = { "start", "eol", "indent" }
vim.opt.path:append({ "**" }) -- Finding files - Search down into subfolders
vim.opt.wildignore:append({ "*/node_modules/*" })
vim.opt.splitbelow = true -- Put new windows below current
vim.opt.splitright = true -- Put new windows right of current
vim.opt.splitkeep = "cursor"
vim.opt.mouse = ""
vim.g.deprecation_warnings = true

-- Undercurl
vim.cmd([[let &t_Cs = "\e[4:3m"]])
vim.cmd([[let &t_Ce = "\e[4:0m"]])

-- Add asterisks in block comments
vim.opt.formatoptions:append({ "r" })

vim.cmd([[au BufNewFile,BufRead *.astro setf astro]])
vim.cmd([[au BufNewFile,BufRead Podfile setf ruby]])

if vim.fn.has("nvim-0.8") == 1 then
    vim.opt.cmdheight = 0
end

Honestly, I don’t want this post to be too long, so I’ll cover the Plugin configuration section in the next article.

My dotfiles configurations:

crafts69guy / .dotfiles

This repo leverages GNU Stow to simplify symlink management, making it easy to install and update configurations across different machines.

Warning: Don’t blindly use my settings unless you know what that entails. Use at your own risk!

📌 Contents

Neovim – Custom plugins, keybindings, and themes
Tmux – Optimized terminal workflow
Git – Configuration for efficient version control
Karabiner – Custom key mappings for Vim efficiency
Fish Shell – Enhanced terminal experience
GNU Stow – Simple dotfiles management

🚀 Setting Up a New Machine with This Repo

This repository uses GNU Stow to manage dotfiles efficiently with symlinks. Follow these steps to set up your new machine:

1. Install Required Packages

Install Stow & Essential Tools

macOS:

brew install stow git fish tmux neovim

Linux (Debian/Ubuntu):

sudo apt update && sudo apt install stow git fish tmux neovim

Linux (Arch):

sudo pacman -S stow git fish tmux neovim

Install Fisher

A plugin manager for Fish
macOS:

curl -sL https://raw.githubusercontent.com/jorgebucaran/fisher/main/functions/fisher.fish | source && fisher install jorgebucaran/fisher

Install Tide after installed

…

Crafts 69 GuyFollow

Web Developer 🧑‍💻

See you soon, comrades, in the next part.

Thanks for reading!

Level Up Your Dev Workflow: Conquer Web Development with a Blazing Fast Neovim Setup (Part 1)

Crafts 69 Guy — Sat, 16 Mar 2024 08:05:49 +0000

Building the Foundation with LazyVim
Why LazyVim?
Getting Started with LazyVim
- Step 1: Back Up Your Existing Neovim Files (Just in Case)
- Step 2: Install Optional Tools (Makes things smoother)
- Step 3: Clone the LazyVim Starter Pack
- Step 4: Remove the .git Folder (Keeps things clean)
- Step 5: Launch Neovim and Witness the Magic!

Hey developers! Tired of clunky text editors slowing down your coding flow? Today, we're embarking on a journey to craft your dream development environment – a modern Neovim setup turbocharged with LazyVim!

This three-part series will be your one-stop shop for mastering Neovim with LazyVim. Buckle up as we transform you from a Neovim novice to a customization ninja:

Part 1: Building the Foundation with LazyVim (This Post): We'll lay the groundwork by installing and configuring LazyVim, your springboard to a supercharged coding experience.
Part 2: Forging Your Neovim Forge: In the second part, we'll delve into the art of customization! We'll explore themes, keymaps, and essential plugins to mold your Neovim environment into a finely-tuned machine that reflects your unique workflow.
Part 3: Unleash the Neovim Beast (Part 3): Get ready to unleash the full potential of your Neovim setup! We'll dive deep into advanced configuration, exploring powerful plugins, customizing the status line for ultimate efficiency, and equipping you with battle-tested tips to optimize your development workflow. This is where you'll truly transform into a Neovim master, coding like a superhero!

Part 1: Building the Foundation with LazyVim

In this first part, we'll establish a rock-solid foundation using LazyVim, a fantastic pre-configured Neovim solution specifically designed for web development. We'll cover everything from installation to launching your first project, ensuring you have a smooth and efficient editing experience ready for further personalization.

Get ready to ditch the frustration and embrace a supercharged development experience! Let's dive in!

You can get my setup on GitHub here:

crafts69guy / .dotfiles

This repo leverages GNU Stow to simplify symlink management, making it easy to install and update configurations across different machines.

Warning: Don’t blindly use my settings unless you know what that entails. Use at your own risk!

📌 Contents

Neovim – Custom plugins, keybindings, and themes
Tmux – Optimized terminal workflow
Git – Configuration for efficient version control
Karabiner – Custom key mappings for Vim efficiency
Fish Shell – Enhanced terminal experience
GNU Stow – Simple dotfiles management

🚀 Setting Up a New Machine with This Repo

This repository uses GNU Stow to manage dotfiles efficiently with symlinks. Follow these steps to set up your new machine:

1. Install Required Packages

Install Stow & Essential Tools

macOS:

brew install stow git fish tmux neovim

Linux (Debian/Ubuntu):

sudo apt update && sudo apt install stow git fish tmux neovim

Linux (Arch):

sudo pacman -S stow git fish tmux neovim

Install Fisher

A plugin manager for Fish
macOS:

curl -sL https://raw.githubusercontent.com/jorgebucaran/fisher/main/functions/fisher.fish | source && fisher install jorgebucaran/fisher

Install Tide after installed

…

Why LazyVim?

There are many great Neovim setups out there, but LazyVim won me over for a few reasons:

Easy Updates: Keeping your Neovim setup up-to-date is essential. LazyVim makes this a breeze with a simple command to update plugins. No more hunting down updates and fiddling with configurations!
Pre-installed Plugins: LazyVim comes with a bunch of popular plugins already configured, saving you tons of time. It's like having a well-stocked toolbox right out of the box.
Flexible Customization: Don't worry, LazyVim isn't a rigid dictatorship. You can easily customize it with your own themes, keymaps, and other preferences. We'll get to that later!

Image source: Lazy documentation

Getting Started with LazyVim

Alright, let's dive into the setup process. Here's what you'll need:

Neovim: Make sure you have Neovim installed on your system. You can check the official website for installation instructions: https://neovim.io/
Git: We'll be using Git to clone the LazyVim starter pack. If you don't have Git, you can download it from https://git-scm.com/downloads

Step 1: Back Up Your Existing Neovim Files (Just in Case)

Before we start fresh, it's always a good idea to back up any existing Neovim configurations you might have. This way, you can easily revert if needed. You can use commands like:

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

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

These commands will move your existing Neovim configuration to a backup folder named nvim.bak.

You get a bare vim.

Step 2: Install Optional Tools (Makes things smoother)

LazyVim works great on its own, but there are a couple of optional tools that can enhance your experience:

ripgrep: A super-fast file searcher. You can install it using your system's package manager (e.g., brew install ripgrep on macOS).
fd: Another blazing-fast file finder. Installation instructions can be found here: https://github.com/sharkdp/fd

Step 3: Clone the LazyVim Starter Pack

Now for the fun part! Open your terminal and navigate to your desired installation directory. We'll use the git clone command to download the LazyVim starter pack:

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

This command clones the LazyVim starter pack into your Neovim configuration directory (~/.config/nvim).

Step 4: Remove the .git Folder (Keeps things clean)

The LazyVim starter pack comes with a .git folder for version control purposes. Since we won't be actively contributing to the LazyVim codebase, we can remove this folder for a cleaner setup:

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

Step 5: Launch Neovim and Witness the Magic!

Now you're ready to experience the power of LazyVim! Open your terminal and launch Neovim using the command:

nvim

Neovim will launch, and you'll see a message indicating that plugins are being installed automatically. This might take a few moments depending on your internet speed.

Explore Your New Playground!

In the next article, we'll dive into personalizing your LazyVim setup with custom themes, keymaps, and more. Stay tuned!

Crafts 69 GuyFollow

Web Developer 🧑‍💻

See you soon.

Thanks for reading!

Neovim: A Powerful and Customizable Text Editor - An Introduction for Beginners

Crafts 69 Guy — Sun, 10 Mar 2024 04:38:25 +0000

Neovim is a modern, powerful, and highly customizable text editor that builds upon thei foundation of Vim. It offers a familiar experience for Vim users while introducing improvements and features for a smoother workflow. This blog post will serve as a gentle introduction to Neovim, covering the basics to get you started.

What is Neovim?
Neovim is a fork of Vim, aiming to provide a better user experience and a more modern codebase. This allows for easier plugin development and integration with external tools. While it retains the core functionality of Vim, Neovim offers several advantages:

Improved Stability: The codebase has been refactored for better stability and performance.
Enhanced Plugin System: Neovim boasts a more user-friendly plugin system, making it easier to extend its functionality.
Modern Features: It supports features like asynchronous operations and better integration with other applications.

Getting Started with Neovim
There are two main ways to get started with Neovim:

Installation: You can install Neovim directly through your system's package manager. This is the simplest method for most users.
Building from Source: For more control over the installation process, you can compile Neovim from source code.
Once installed, you can launch Neovim from your terminal by typing nvim.

Basic Navigation and Editing

Neovim operates in two primary modes: Insert Mode and Normal Mode. Understanding these modes is crucial for efficient text editing in Neovim.

Insert Mode

Insert mode functions similarly to most text editors. You can type characters directly to insert text at the cursor position. Insert mode is activated by pressing i, a, o, or other insertion commands depending on where you want to insert text.

Here are some key things to remember in Insert mode:

Standard editing keys like Backspace, Delete, arrow keys, and Home/End work as expected.
Pressing Esc exits Insert mode and returns you to Normal mode.

Normal Mode

Normal mode is the heart of Neovim's editing power. It allows you to perform various actions on text using keyboard shortcuts. While it might feel unconventional at first, mastering these shortcuts leads to a fast and efficient workflow.

Here are some essential navigation and editing commands in Normal mode:

Movement:

h, j, k, l: Move the cursor left, down, up, and right by one character, respectively.

w (word): Move the cursor to the beginning of the next word.
b (beginning of word): Move the cursor to the beginning of the previous word.
e (end of word): Move the cursor to the end of the current word.

0 (zero): Move the cursor to the beginning of the line.
$ (end of line): Move the cursor to the end of the line.
G: Move the cursor to a specific line number (e.g., 10G goes to line 10).
gg: Move the cursor to the beginning of the file.
G: Move the cursor to the end of the file.

Deletion:

x: Delete the character under the cursor.
X: Delete the character before the cursor.
dd: Delete the current line.
d{motion}: Combine deletion with a motion (e.g., dw deletes the current word). Common motions include w (word), b (beginning of word), e (end of word), t (until a character), and $ (end of line).

Copying and Pasting:

y{motion}: Copy the text defined by the motion (similar to deletion).
p: Paste the copied text at the cursor position.

Repeating Commands:

A number before a command repeats it that many times (e.g., 3dd deletes three lines).
These are just a handful of essential commands. Neovim offers a vast array of navigation and editing options based on motions, operators, and combinations. The key is to understand the basic concepts and gradually build your repertoire of commands for efficient editing.

Tips for Mastering Normal Mode:

Practice using the hjkl keys for navigation instead of arrow keys. This keeps your hands on the home row for faster movement.
Learn common motions like w, b, and e for efficient word-based editing.
Combine motions with operators like d for powerful deletion commands.
Explore the official Neovim documentation https://neovim.io/doc/ for a comprehensive list of commands and explanations.
By mastering these basic navigation and editing techniques in Normal mode, you'll unlock the true power and efficiency of Neovim!

Exploring Further
The beauty of Neovim lies in its customizability. You can leverage plugins to enhance its functionality and personalize your workflow. Popular plugins include:

NERDTree: Provides a file explorer sidebar for easy project navigation.
Coc.nvim: Offers auto-completion and language support for various programming languages.
LSP clients: Integrate with Language Server Protocols (LSP) for advanced features like code navigation and diagnostics.
There are vast resources available online to delve deeper into Neovim. The official documentation https://neovim.io/doc/ is a great place to start.
Additionally, numerous communities and forums cater to Neovim users, providing tutorials, tips, and configurations to explore.

This blog post serves as a springboard for your Neovim journey. With its powerful features and customization options, Neovim can become a valuable tool for developers and programmers of all experience levels. So, dive in, explore, and unleash your coding potential with Neovim!

Crafts 69 GuyFollow

Web Developer 🧑‍💻