--- title: Linux, Python, Vim & Git (LPvg) Your Minimum Tech Toolkit for Life permalink: /futureproof/LPvg/ description: This article advocates for adopting a minimalist yet powerful tech toolkit centered around Linux, Python, Vim, and Git (LPvg). This stack, combined with tools like Nix, Jupyter Notebooks, and FastHTML, provides a foundation for future-proof tech skills, emphasizing portability, open-source freedom, and adaptability in an ever-evolving technological landscape. This approach prioritizes fundamental skills and avoids the constant churn of trendy frameworks, enabling lifelong learning and mastery of essential tools for various domains, including web development and AI integration. meta_description: Adopt the LPvg minimum tech toolkit (Linux, Python, Vim, Git) with Nix/NixOS for portable, reproducible environments and lasting skills. meta_keywords: LPvg, Linux, Python, Vim, Git, Nix, NixOS, minimum viable platform, tech toolkit, future-proof, portable environment, reproducible environment, declarative configuration, JupyterLab, FastHTML, HTMX, package manager, dependency management, container alternative, open source layout: post sort_order: 1 --- ## The Portability of Unix and Its Open-Source Legacy Continues There's a larger discussion here about **Unix** and the portability of everything, and a whole "bad boy" philosophy of yanking back the good stuff for the masses after corporate greed appropriates it. As GE and Bell Labs almost did from Fernando Corbató with **Multics** until the still-living national treasure **Ken Thompson** yanked it back with **Unix**. That got absconded with once again by big tech, so **Linus Torvalds** yanked it back with **Linux**, in an eternally repeating story. --- ## The Power of LPvg Today, a smattering of the tools that they created and liberated can't be taken away from you by vendor shenanigans because they're the very tools *they* have to use to build their own stuff. And with the exception of the **C programming language**—which takes a level of something that I seem to not have—I find the others manageable over time with practice, even the legendarily difficult **Vim** text editor that everyone builds the "mode" for in. **Find out why.** --- ## A Minimum Viable Platform for Life I advocate **Linux**, **Python**, **Vim**, and **Git**, collectively the **LPvg**, as the minimum viable platform for life. There's plenty of other stuff you can (and should) take up in life for your day job, as the right tool for the job or whatever. But having LPvg in your back pocket future-proofs you and makes you able to do stuff and be a valuable contributor in almost any environment today and long into the future. --- ## Interactive Learning with Jupyter Notebooks Now, there's also **Jupyter Notebooks** for a generic, free and open-source software (FOSS) place to run your Python in a fun and interactive web-based way that doesn't require the cloud. It is neither Microsoft **VSCode** nor **Google Colab**, though they both emulate it. And it's **JupyterLab**, in particular, to stave off having to use Vim right away, and to get interactive web dashboards in addition to embedding Markdown documentation and code in a shareable form. --- ## Efficient Web Development with FastHTML and HTMX As we expand our toolkit, the ability to run web applications locally becomes increasingly valuable. Enter **FastHTML**, which leverages **HTMX** to bring a small amount of Pythonic web development into the picture without dragging us into the JavaScript framework hamster wheel. **FastHTML** allows you to build dynamic web applications using your existing Python knowledge, keeping the focus on server-side logic while **HTMX** handles the client-side interactions seamlessly. This approach ensures that you: - **Leverage Python Know-How**: Utilize Python for both backend and frontend interactions, minimizing context switching between languages. - **Avoid JavaScript Rabbit Holes**: Steer clear of complex JavaScript frameworks and DOM manipulation, reducing overhead and learning curves. - **Run Locally with Ease**: Develop and test web applications on your local machine without the need for extensive setup or external dependencies. ### Embracing Simplicity with HTMX **HTMX** is a lightweight JavaScript library that enables you to perform AJAX requests, WebSockets, and server-sent events directly from HTML attributes. It works hand-in-hand with Python frameworks like **FastHTML** to: - **Enhance User Experience**: Create interactive web pages without full-page reloads. - **Maintain Clean Codebase**: Keep your codebase simple and maintainable by avoiding heavy frontend frameworks. - **Stay Productive**: Focus on delivering features rather than wrestling with complex tooling. By integrating **FastHTML** and **HTMX** into your LPvg toolkit, you gain the ability to develop modern web applications efficiently, all while staying within the comfort zone of Python. --- ## The Game Changer: Nix And you know what? The final piece just fell into place. It's called **Nix**. And **NixOS**, but you need not use the OS, necessarily. Nix scratches various itches. A big one is a way for Mac and Windows users to exchange definition scripts for fully working environments, including software from a huge Nix software repository system. --- ## Simplifying Environment Sharing So if you don't want to build something as a web app, and you maybe want it to run from a Python Notebook or a local web server using **FastHTML**, and be shareable, **Nix** provides easy environment sharing so you don't have to follow tedious install instructions every time you need to spin up such-and-such a system. And it's without containers or virtual machines. These system definitions start with a simple `configuration.nix` file. --- ## The Power of Configuration Almost any tutorial you find that shows you how to build a system has a long process of "install this, then do that," getting all the components that the application is dependent on onto your system, then configuring it to work. A popular shortcut lately has been container technology such as **Docker**, which has its own set of issues. Alternatively, **Nix** is an **imperative system configuration language**, like **SQL** or **HTML**, but for configuring whole systems that does away with the need, generally with a single file that replaces all: *Examples of package managers replaced by Nix:* - `apt-get` (Debian, Ubuntu) - **Homebrew** (macOS) - `pip` (Python) - `virtualenv`, `venv`, `pipenv`, `poetry`, etc. (Python) - **Conda** (Python, R, and other scientific computing) - `npm` (Node.js) - `gem` (Ruby) - **Composer** (PHP) - **Cargo** (Rust) - `yum` (Red Hat, CentOS) - `dnf` (Fedora, newer Red Hat-based systems) - `zypper` (openSUSE) - `pacman` (Arch Linux) - **winget** (Windows) - **Chocolatey** (Windows) - **Scoop** (Windows) - **Maven** (Java) - **Gradle** (Java, Kotlin, Android) - **NuGet** (C#, .NET) - **Yarn** (JavaScript, alternative to npm) - **vcpkg** (C++) - **Conan** (C/C++) - `apk` (Alpine Linux) - **Portage** (Gentoo Linux) - **Flatpak** (Linux, distribution-agnostic) - **Snap** (Ubuntu, other Linux distributions) - **AppImage** (Linux, distribution-agnostic) - Custom drivers or environment variable stuff baked in If you're using **NixOS**, you configure generally a single `configuration.nix` file—like a great big JSON file—that defines your system, and *ta-da!* Portable system for life. The configuration files work great in **Git** repositories. For more granular control, there's a system called **Nix Flakes**. If you're on Mac or Windows, you get most of the same benefits by using the `nix` command from within subfolders of Macs or Windows (generally, with **WSL**). --- ## A New Era of Portability This portable tech system without containers or VMs that works across different hardware (with some occasional adjustments) appeals to me. More than a decade ago, I created **Levinux**, a highly portable **QEMU**-based VM for hacking around with. But it was a lot of moving parts to wrangle for such little performance. But I made attempts at building what I was looking for. I also played around with containers, and not just Docker, but also Ubuntu's **LXD**, which was great for those who loved reliable pre-built containers you could treat like a fresh install, so you can script some level of reproducibility. --- ## The Limitations of Containers But such cobbled-together system-building approaches from containers are not something that cuts across decades. A script to build the exact same thing from the exact same historical (often GitHub) places, if not already cached, ensures everything's pinned with working versions and a sort of undo/redo, rebuild-from-scratch small tech stack that will travel well. --- ## The Benefits of a Repository System Such a repo system not only lets you set up an entire running **NixOS** system—which is a popular use for Nix (what I now use)—but it also lets you create sub-systems on either: - **macOS** - **Windows** - The **Windows Subsystem for Linux (WSL)** - Other **Linux** distributions that are exactly the same across different machines. And this is where getting better at tech tools for life comes in.
graph TD A[Nix Repository System] --> B[NixOS] A --> C[Sub-systems on macOS] A --> D[Sub-systems on Windows] A --> E[Sub-systems on WSL] A --> F[Sub-systems on Other Linuxes] B & C & D & E & F --> G[Consistent Environments]
--- ## Mastering LPvg for Lifelong Improvement You define a good **Linux**, **Python**, **Vim**, & **Git** (LPvg) to travel with you, and get good at using this small set of tools on a wide set of problems, and improve for life in tech, like you can in: - **Music** - **Sports** - **Woodworking** - **Web Development** (with tools like **FastHTML** and **HTMX**) - Or anything where the tools let you improve forever for life, without so much churn that it's hardly worth learning everything --- ## Embrace the Future with NixOS Each of these tools is a potential rabbit hole in their own right, especially **Linux**. But if you're resisting obsolescence with a vengeance, after you've learned the basics with a version like **Ubuntu** or **OpenSUSE**, you're going to want to look at **NixOS**, the ultimate in infusing the spirit of the machine into new hardware from now to forever. Even virtual machines and containers seem kind of silly in comparison. --- ## Mastering NixOS And LPvg For Lifelong Technological Empowerment By embracing **NixOS** and mastering **LPvg**, along with Pythonic web development tools like **FastHTML** and **HTMX**, you set yourself up for a lifetime of technological empowerment. The ability to craft, control, and reproduce your computing environment across any hardware ensures that you remain relevant and effective, no matter how technology evolves. --- ## Building Dynamic Web Applications with Python Tools *Incorporating tools like FastHTML and HTMX allows us to expand our LPvg toolkit into the realm of web development without getting entangled in the complexities of JavaScript frameworks. By leveraging our existing Python knowledge, we can build dynamic web applications efficiently and maintain control over our tech stack.*