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.
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.