LPvg: Timeless Tech Skills for the AI Age
`Linux`: The open-source pulse of global computation.`Python`: Language of logic, creativity, and discovery.`vim`: Text whisperer—zen efficiency in keystrokes.`git`: Memory keeper—track, share & find your way.
That’s the main minimal tech-stack as a sort of swiss army knife 🇨🇭 or utility belt of tech 🦸♂️. You don’t need to use it for everything, but it is applicable to anything 🌍. With a few more tools 🛠️, we lower the barrier to entry and make systems reproducible across all hardware (️🍎🪟🐧). Plus, we’ll sprinkle in the free local AI 🤖🧠 and a Python-centric 🐍 web development environment.
`nix/NixOS`: Reproducibility redefined—consistency across the code cosmos.`tmux`: Command-line conjurer—sessions split, disconnected, and reborn.`Jupyter Notebooks`: Code meets canvas—prototype, iterate, illuminate.`FastHTML`: From Pythonic thoughts to web realities in a heartbeat.`Ollama`: Listening offline AI—a secure local companion in thought.
___
| | _____
|_ | / \
\ | | \
| \ | /
\ \____ \_ \
\ \_/ |
___. \_ _/
.-, / \ | |
| \ _/ `--_/ \_
\ \________/ /\ \
| / \_ \
`-----------, | \ \
| / \ |
| | | \
/ | \__|
/ _ |
/ / \_ \
| / \__ __--`
_/ / \ _/
___/ / \_/
/ /
`----`
Writing as a Compass in the Tech Wilderness
📝 I don’t write because I crave an audience or have products to peddle. My words are my 🧭 compass, helping me navigate the ever-shifting landscape of 💻 technology. This digital journal is my 🔊 sounding board, a space where ideas 🔉 echo and 💎 crystallize. With each post, I’m forging a 🛤️ path forward, articulating the complex, and holding myself accountable to the journey I’ve chosen—and 🛠️ practicing my craft.
Make Their Mission Mine
November 06, 2024
Resilience While Achieving Ikigai
November 06, 2024Exploring the Japanese concept of Ikigai as a path to resilience - aligning what you love, what you're good at, what pays, and what the world needs. Finding joy and meaning in life's journey while building mental toughness.
Getting Mac NeoVim Same as NixOS NeoVim
November 05, 2024Tame the Mac! 💻 This is my journey to conquer the increasingly dreaded Macbook and make it work seamlessly with my increasingly beloved NixOS NeoVim setup. From battling muscle memory to embracing the power of flakes, I'm crafting my ultimate cross-platform development environment. 🚀
Figuring Out a Complex API
November 04, 2024Coding like the 3 Little Pigs? Yup. Building straw houses with an eye on the future. It's about good kata, adapting to change, and the AI-powered webdev renaissance. HTMX FTW!
SSE Makes Watchdog Necessary to Force Server Live-Reload
November 03, 2024Waiting for connections to close? (CTRL+C to force quit?) Discover why adding SSE to FastHTML demands a more heavyweight solution for live-reloading, and how using a watchdog brings your dev environment back to life—Wile E. Coyote-style—with every file save.
API-Enabling the LLM Ghost
November 03, 2024Unlock the hidden potential of an LLM that’s not just in the background but visibly alive in your browser. This deep dive explores the path to seamless, human-like control of CRUD operations through an HTMX-powered proof of concept, bridging the uncanny valley between human interaction and AI control, where every action could look like it’s yours.
How I Finally Got My LLM to Play Nice With the Web UI
November 02, 2024Embark on a journey bridging the gap between WebSockets, Server-Sent Events (SSE), and JavaScript to bring the "Ghost in the Machine" to life. Discover how a methodical approach, inspired by the Wright Brothers' experiments, led to a system where real-time commands and structured responses create an interactive, dynamic web experience. From initial spark to lift-off, this article shows how persistence and well-planned steps make complex integrations not just achievable, but thrilling.
FastHTML Hello World
November 02, 2024Learn the basics of FastHTML, a Python web framework that skips templating languages and allows direct HTML element creation with Python functions. Discover how to build a simple "Hello World" page with structured HTML using FastHTML's function-to-element mapping.
Deep Debugging LLM Ghost
November 01, 2024A deep dive into the challenges of integrating LLMs with dynamic web UIs using HTMX and FastHTML. Explore the pitfalls of misusing WebSockets, the complexities of parsing assistant responses, and the eventual triumph of Server-Sent Events.
Rabbit Hole Dev to Delight Clients
October 31, 2024Join me on a journey through the exhilarating world of development, where I balance the addictive nature of AI-driven coding with the need to engage clients. Discover how I navigate the challenges of maintaining flow states, embracing resilience like Rocky Balboa, and leveraging small wins to drive success in a fast-paced tech landscape.
Giving Gemini Advanced a Try
October 30, 2024Exploring Gemini Advanced, I use fresh web logs each session to fine-tune API syntax and JSON commands for enhanced clarity in LLM interactions. By examining logs, adjusting placeholder syntax, and reformatting responses with real-world examples, I improve the LLM’s system prompts to support smoother CRUD operations and dynamic UI updates. Each step refines both the app and the model, helping me achieve real-time updates in the UI with precision.
It's About Delighting Customers
October 30, 2024Through my experiences with AI and customer-focused methodologies inspired by Drucker and Deming, I've learned that technology's true worth is measured by its ability to delight clients. By prioritizing value from the customer's perspective and streamlining processes, I harness AI to create data-driven approaches that empower my clients to shine and engage their audiences effectively.
LLM as Ambient App Intelligence
October 29, 2024In this article, I dive into the concept of LLMs as ambient intelligence, inspired by a conversation with Claude 3.5 through Cursor AI. I explore how integrating AI seamlessly into user interactions creates smarter workflows, allowing apps to learn and assist in real-time. As I transition from architecture to client focus, I reflect on how combining Drucker’s customer-first philosophy with Deming’s incremental improvement approach ensures AI remains a tool for delighting customers, not a distraction from what matters most.
FastMTML Static Resources
October 28, 2024Explore the FastHTML project, a Python-based framework embracing anti-patterns for simplicity and power. Dive into package initialization, global namespaces, and how HTMX equips the Python community with new web development superpowers, driving a unique approach that challenges conventional JavaScript frameworks like ReactJS.
Slack & Zoom on NixOS Workspaces
October 27, 2024I show how NixOS makes installing Slack & Zoom easy, how I use virtual desktops across OS platforms, and how organizing fixed-position screens helps me stay in the flow with muscle memory guiding my workflow.
Pythonic Chunk-Yielding Generator to Simulate Long-Running Tasks
October 26, 2024Simulate long-running tasks with Python using a chunk-yielding generator for streaming WebSocket chit-chat. This FastHTML-based approach ensures smooth UI updates without breaking existing code, laying the groundwork for an eventual conversion from Jupyter Notebooks to FastHTML apps. Also, I train Claude that FastHTML is not FastAPI.
I Don't Know What to Do Sometimes
October 25, 2024SPAs reshaped SEO, but I’ve adapted along the way. While I missed some chances, I still love coding, writing, and experimenting with tools like NixOS and GitHub Pages. Now, I’m channeling that energy into a new goal: converting my Jupyter Notebook workflow into a FastHTML-powered app, creating a seamless, interactive experience I can't wait to share.
API, AI & Human Nuance: The Same Thing
October 24, 2024Explore the connections between APIs, AI, and human nuance in modern workflows. This article offers practical strategies for navigating technological subtleties, enhancing productivity, and building strong client relationships, all while balancing innovation with authentic interactions.
The Port For Real This Time
October 23, 2024Porting two key apps has been delayed, but I'm determined to finish tonight while preparing for a client call tomorrow. I’m shifting from ZeroMQ to WebSockets for real-time communication and simplifying data handling with SQLite. The focus is on progressive UI elements and Botify API integration to streamline workflows, avoid rabbit holes, and ensure meaningful progress.
LLM Ghost In The Machine
October 22, 2024I dive into the ups and downs of using AI like OpenAI and Cursor AI for code refactoring, especially with frameworks like FastHTML and HTMX. I’ve had wins with CRUD operations and syntax-colored logs, but also setbacks with error handling. The key lesson? Balance global vs. targeted AI edits and keep things simple. I’m also streamlining my setup with helper scripts and macros in NixOS, turning small improvements into lasting productivity boosts.
Local AI Awareness Training
October 21, 2024Learn how to integrate local LLMs with FastHTML to build CRUD apps. Conversation history is logged in SQL and vector databases for insights. The LLM aids user actions and prepares for future self-sufficiency by learning app usage patterns, enhancing AI-driven workflows.
Local AI In The App Development Loop
October 20, 2024Exploring AI-powered app development, this article covers lessons from building with HTMX, WebSockets, and local LLMs. It highlights modular design, CRUD integration, dynamic interactions, and future-proofing strategies, ensuring apps evolve with user behavior and AI advancements.
Planning to Win with LLM
October 19, 2024Planning to Win with LLM highlights how LLMs reduce planning friction by offering mentorship on common scenarios but struggle with novel insights. It emphasizes leveraging AI for SEO and using WebSockets to track user actions, blending AI strengths with adaptability for future innovations.
Local LLM Web Framework Integration Plan
October 18, 2024Collab with o1-preview to design a local LLM, vector database, and SQL database on a local host to transform software development. Explore building self-aware systems that interact with developers, execute functions, and improve over time, making AI an active participant in its own design.
Revolutionizing Software Deployment: How Nix Flakes Simplify Development Beyond Docker and pip
October 17, 2024Discover how Nix Flakes are transforming the development landscape by offering a streamlined, reproducible environment that outperforms traditional methods like Docker and pip installations. This article delves into the advantages of using Nix Flakes for infrastructure as code, highlighting how it simplifies user experience, ensures cross-platform consistency, and automates setup and updates.
The key to AI Code Assist Acceleration is 1-Folder Scope
October 15, 2024Explore how moving a key NixOS config to a 'repos' folder accelerates AI coding assistance with Cursor AI. Learn about challenges with Vim macros, AI limitations, and tips for consolidating development resources while leveraging cross-repo insights for coding efficiency.
Soft Launching Botifython
October 15, 2024My journey upgrading Botifython's Pipulate fork with Nix flakes, transforming Jupyter Notebooks into web apps, and deploying to coworkers. From FOSS to proprietary shifts, embracing infrastructure as code, and automating SEO workflows—crafting tech with passion and precision.
Botifython is Born
October 14, 2024I’m diving back into web development through Botifython, a Python framework focused on SEO and AI, driven by new technology. My setup utilizes Nix Flakes for reproducible environments and includes an automated update mechanism with SSH keys, ensuring seamless integration of new features. I’m excited to evolve this project with stable and experimental branches as I continue to enhance its capabilities.
Object Oriented Base Class Plugins
October 13, 2024I've built a plugin system using object-oriented programming, something I was initially hesitant about due to Python's OOP syntax. By creating a base class, `BaseApp`, I've streamlined CRUD operations and routes, improving the system's long-term flexibility. This approach reduces complexity in my single-file setup. I’ve customized the base class with wrappers like `TodoApp` and `ProfileApp` for specific functionalities. This shift to precision coding lets me add new features, like sorting, without bloating the code, making the system easier to update and maintain.
Building a Plugin-Ready Framework: A Step-by-Step Transformation
October 12, 2024Discover how I restructured my system into a plugin-ready framework, enhancing modularity and simplifying updates. This guide outlines the transformative steps taken, highlighting the benefits of a modular design for improved scalability, maintainability, and collaborative development.
Test SPA Endpoints (Single Page Applications in FastHTML)
October 11, 2024This article details the development of a comprehensive testing suite for a FastHTML single-page application using Python's `unittest`. It covers endpoint testing, logging enhancements, and future plans for UI automation, ensuring the application’s reliability and robustness while showcasing code snippets for clarity.
FastHTML and SortableJS For Sortable Todo Lists
October 10, 2024This article explores how to integrate SortableJS with FastHTML for creating sortable to-do lists. It covers client-side drag-and-drop functionality, efficient backend updates using MiniDataAPI, and setting up JavaScript and Python endpoints for real-time updates.
AI-Generated Refactoring Advice from Top LLM Models
October 09, 2024Learn how to integrate AI-powered refactoring advice from Claude 3.5 Sonnet and OpenAI ChatGPT o1-Preview into a Python web framework using FastHTML. This guide walks you through setting up refactoring systems and enhancing workflow with cutting-edge AI models.
Unpacking FastHTML Databases
October 08, 2024The article explores the complexities and nuances of the FastHTML framework, emphasizing its layered architecture built on Python and Starlette. It discusses the challenges of adapting to new conventions while developing a Pythonic API wrapper, highlighting the importance of understanding evolving frameworks for effective web development.
A ChatGPT o1-Preview Code Review
October 07, 2024Building the next generation of Pipulate with FastHTML has been challenging but rewarding. After overcoming hurdles with HTMX and real-time streaming, I'm excited about the potential for powerful local web apps built in Python, easily shareable across platforms.
FastHTML WebSockets & Database for Streaming & Persistence
October 06, 2024FastHTML simplifies web dev with built-in SQLite support, WebSockets, and HTMX. It enables easy database setup, real-time updates, and server-side rendering. The article chronicles a shift from custom solutions to leveraging FastHTML's streamlined features for persistence and communication.
Ollama Websocket Chat
October 05, 2024WebSocket technology enables efficient real-time chat and responsive UIs, replacing older methods like polling. The article discusses various streaming techniques, including ZeroMQ, and proposes combining FastHTML HTMX with Ollama chat for a web-based AI chatbot.
Understanding FastHTML's Framework Opinions
October 04, 2024Comming to grips with how opinionated a framework FastHTML really is, but deciding it's still worth it, if I can decipher the intuitively correct feeling HTMX approach, coupled with Python functions named for HTML tags.
From Jupyer Notebooks to FastHTML with WebSockets
October 03, 2024Getting Back into Web Programming with Jupyter Notebooks and FastHTML, getting down the basic trick of Streaming Messges from long-running tasks using HTMX and WebSockets.
Code as Infrastructure
October 02, 2024Discover how Nix Flakes transform infrastructure as code, providing platform independence, reproducible environments, and streamlined DevOps. Achieve hardware freedom and enhance your career with this powerful, flexible tool for modern developers.
Melding a Mac and Linux Nix Flake
October 01, 2024Create a unified development environment using Nix Flakes across macOS, Linux, and Windows WSL. My approach ensures smooth setup, optional CUDA support, and easy control with tmux-based scripts, streamlining JupyterLab launches. This builds the foundation for robust multi-platform data science workflows.
Forking a Flake of Infrastructure as Code
September 27, 2024Creating a portable foundation for every project using Nix Flakes and Infrastructure as Code, ensuring a consistent starting point across platforms while avoiding architecture over-engineering. This approach balances practical needs and reusability, making development smooth and adaptable.
There's No Home Like Nix
September 26, 2024This article explores building a reproducible development environment using Nix, focusing on creating a "home" script to streamline setup across platforms. It highlights Nix flakes, simplicity in tech, and modernizing apps like Pipulate with AI in FastHTML.
The DevOps Renaissance: How Infrastructure as Code is Redefining Digital Craftsmanship
September 25, 2024Explore the resurgence of the polymath in DevOps, where Infrastructure as Code is enabling small teams to achieve unprecedented scale and efficiency. Discover how continuous refinement of IaC transforms DevOps engineers into digital artisans, shaping the future of software development.
FastHTML and Cursor AI on Linux, Mac & Windows
September 24, 2024Learn how to integrate FastHTML and Cursor AI using Nix across Mac, Windows, and Linux. This guide walks through setting up a cross-platform development environment, handling NixOS challenges, and ensuring compatibility with popular tools.
Using NixOS and Nix with Pip Install DotEnv
September 23, 2024Leverage NixOS and Nix with pip to install python-dotenv for managing environment variables. This guide walks you through setting up reproducible Python environments, securely handling secrets, and integrating tools like FastHTML and Ollama for efficient development under Nix.
Getting My Nix System Together
September 22, 2024Discover Nix and NixOS for reproducible systems. Learn to configure NixOS, set up data science environments, and manage Python dependencies, balancing Nix's determinism with Python's flexibility.
Updating NixOS
September 17, 2024Discover Nix and NixOS essentials, including transitioning from Ubuntu and Fedora, understanding the unique /nix/store/, and leveraging deterministic packaging on Mac and Windows. Learn how Nix Flakes simplify software management and development environments.
Embracing AI-Assisted Development with Jupyter AI and Nix Flakes
September 16, 2024Learn how to modify a `flake.nix` to create a flexible development environment with JupyterLab, CUDA support, AI-assisted tools like Jupyter AI, and Python virtual environments for enhanced productivity and adaptability.
Cross-Platform Nix Flake for Jupyter & FastHTML
September 15, 2024Learn how I methodically crafted a cross-platform Nix flake that integrates JupyterLab, CUDA support, Ollama for local LLMs, and a FastHTML server, leveraging virtual environments for maximum flexibility.
Get the Big Tech Picture to Maintain Agency
September 14, 2024Discover the evolution of foundational tech tools—from Unix to Python, Vim, and NixOS—and learn how understanding these principles empowers you to maintain independence and control in today's AI-driven landscape.
My First Nix Flake Will Be JupyterLab
September 13, 2024Exploring how to create a portable and shareable JupyterLab environment using Nix flakes, enabling consistent development workflows across NixOS and macOS.
Getting Started with Nix Flakes
September 12, 2024Discover how Nix Flakes simplify NixOS configuration management. Learn to version control your system setup and streamline your workflow with this step-by-step guide.
Groking the NixOS Langauge
September 10, 2024Pythonista struggles with NixOS, seeking an intuitive grasp of its declarative syntax, functional nature, and abstract structures, navigating challenges in config language comprehension.
Linux, Python, Vim & Git (LPvg) Your Minimum Tech Toolkit for Life
September 09, 2024Master Linux, Python, Vim, and Git (LPvg) as your minimum tech toolkit to stay relevant, resist obsolescence, and embrace open-source freedom with Nix, Jupyter Notebooks, and Pythonic web development using FastHTML and HTMX.
Future-proof Your Tech Skills
September 08, 2024Master the "LPvg stack"—Linux, Python, vim, and git—to future-proof your skills. Focus on fundamentals that transcend trends, avoid vendor lock-in, and maintain autonomy. This toolkit bridges tech with domain expertise, builds lasting muscle memory, and ensures adaptability in an evolving, AI-driven world.
Reproducible Environments: Nix & Cross-Platform DevOps
The full ramifications of reproducible general 🐧Linux subsystems on any host computer (🍎,🪟,🐧) has not sunk in with the tech community (💃🕺🏿) yet. Be it through Nix 🧰 (most likely) or guix 🦬 the GNU project’s official version of the same tech, Docker 🐳 is already… well, not quite obsolete 👻, but certainly 80/20-ruled out of daily needs. Nix Flakes ⛏️, a single text-file alternative carry Infrastructure as Code and can simply be dropped into a git repo. Then you just hydrate💦 it. Or if you prefer, chip a flake.nix off the old configuration.nix core 💎. No bloat 🐳 required.