LPvg: Timeless Tech Skills for the AI Age
`Linux`: The interoperable sub-system of macOS & Windows 😉`Python`: The new English — or "Lingua Franca" of technology.`vim`: How muscle-memory, aka craft, comes to programming.`git`: Making your code unstoppable, unlosable & undoable.
LPvg is a completely free future-proofing minimal tech-stach for life making you a 🦸♂️. Don’t use it for everything, but know you can apply it to anything — because all tech is text. So edit at the speed of thought and the world is your 🦪. Add fully reproducible 🐧 inside any 🍎 or 🪟 folder (without the 🐳) by using ⛏️ off the ol’ 💎. The tech-setup of your dreams is one 💦 away (if you can hydrate a DOM, you can hydrate a LAN).
Simply upgrade from Jabberwocky to Juggernaut and no vorpal 🤺 can stop you. This is the fully vendor-neutral 🦬 FOSS-world I’m talking about folks, where 🤖 AI will only make you 💪!
Also Down the 🐇🕳️ Here at MikeLev.in are:
`nix/NixOS`: Reproducibility redefined—not the death of Docker, but close.`tmux`: Like having devops sysadmin powers with only 1/4th of being an a-hole.`Jupyter Notebooks`: No, not Colab. No, not VSCode. Project Jupyter!!!`FastHTML`: WebDev & HTML the way it should be. Better than React.`Ollama`: 'Cause AI doesn't cost any more than electricity now.
___
| | _____
|_ | / \
\ | | \
| \ | /
\ \____ \_ \
\ \_/ |
___. \_ _/
.-, / \ | |
| \ _/ `--_/ \_
\ \________/ /\ \
| / \_ \
`-----------, | \ \
| / \ |
| | | \
/ | \__|
/ _ |
/ / \_ \
| / \__ __--`
_/ / \ _/
___/ / \_/
/ /
`----`
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 🛠.
Pipulate Pipeline Born Again Now
November 21, 2024
On Flow State Alternation - The Key to Success
November 20, 2024I delve into the concept of flow state and its significance in my SEO work. I examine my personal experiences with flow state, emphasizing its role in boosting my productivity and creativity. I also discuss the potential advantages and challenges of incorporating AI coding assistants into my workflow, and the importance of selecting appropriate programming paradigms and tools that align with my individual needs and preferences. I close with a reflection on the dynamic nature of the tech world and the ongoing need for continuous learning and adaptation.
Pipeline Workflow
November 19, 2024This document details the creation of a system for managing complex workflows on a local machine, inspired by the Unix pipeline concept. It leverages a Python-based web framework (FastHTML) and a minimalist database approach (MiniDataAPI) to create a user-friendly interface for chaining together tasks, passing data between them, and managing state efficiently. This system aims to simplify and streamline complex processes, particularly those involving web scraping, data analysis, and automation, all while remaining lightweight and user-friendly.
Pattern Alert - THIS IS NOT FASTAPI!
November 18, 2024I detail the process of building a Python web application using the FastHTML framework, emphasizing the importance of simplicity and readability. I draw inspiration from the Unix philosophy and the design principles of ABC, Python, and FastHTML to create maintainable and user-friendly code. I also share my experiences with AI code assistants, highlighting the challenges of preventing them from introducing unnecessary complexity. Through careful prompt engineering and defensive documentation, I successfully refine the code and establish a pattern for building robust web applications with clear state management, explicit state transitions, and comprehensive error handling.
Unix Pipeline Philosophy in HTMX + FastHTML Workflows
November 16, 2024Unix Pipeline Philosophy in HTMX + FastHTML Workflows: Enhance your coding skills by embracing a Unix-inspired approach to building web applications with HTMX and FastHTML.
On Fighting the Dunning-Kruger Effect
November 16, 2024Fighting the Dunning-Kruger effect and trying to actually be that good while building a simple yet powerful web app with a unique architecture. Learn how AI helps combine the best of old-school desktop apps with modern web technologies.
OpenAPI Swagger JSON to Python Code Examples
November 15, 2024I'm building a cutting-edge web framework with HTMX, Nix Flakes, and AI, aiming for a future-proof development experience. It's about user empowerment, skill amplification, and shaping SEO's future. Come along for the ride!
80% Cost Reduction in AI Operations
November 13, 2024I'm exploring a new way to build software that uses AI to make things more efficient and cost-effective. I've created a system that combines different AI models, kind of like having a team of experts with different specialties. This system can learn and adapt over time, and I think it has the potential to change how we build software and make AI more accessible.
6-Click-Ease to Serve Up Bacon
November 12, 2024This post rethinks the web as a dynamic, database-like system, shaped by six degrees of separation and small world theory. It delves into how SEO and AI tools streamline repetitive tasks, align with real-time search demands, and prepare content for the constant crawl and recrawl required to inform modern AI models. By viewing URLs as keys in a vast, cloud-based database, it explores the challenges of navigating a web where trusted brands and creative strategies are essential to standing out.
How To Train Your LLM
November 11, 2024Discover how to train your LLM to work with Botify Query Language (BQL) for efficient SEO analysis. This guide covers everything from understanding BQL's core concepts, such as collections, dimensions, and metrics, to building powerful queries, visualizing data, and integrating LLMs into your workflow with Python examples.
I Know Kung Fu... Show Me!
November 10, 2024Explore how AI assistance and strategic prompt injection enabled mastery of complex BQL API integration, setting the stage for ambitious GPU-powered website visualization goals.
From Jupyter Notebooks to Markdown
November 09, 2024From Jupyter Notebooks to Markdown: A journey through refining workflows, building muscle memory, and perfecting good form in data science. Discover tools like nb-clean and jupytext while developing a sustainable, accessible process for managing and sharing code—keeping technical depth without losing readability.
Practicing the Botify API
November 07, 2024Exploring the Botify API through Python notebooks, examining key concepts like Organizations, Projects, and Collections while considering the future of SEO in an AI-driven world.
Structuring Websites to Train Models
November 07, 2024Learn how to structure websites to train AI models while maintaining a client-first mindset. Explore the balance between technical innovation and delivering value to clients in modern SEO.
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, 2024In my quest to build the perfect to-do list app with FastHTML, I tackled drag-and-drop sorting with SortableJS. After overcoming a pesky </li>
AI-Generated Refactoring Advice from Top LLM Models
October 09, 2024I detail my experience using Nix flakes to create a reproducible development environment for a Python web application built with the FastHTML framework. I discuss the challenges and benefits of using Nix for managing dependencies and ensuring consistency across different platforms, and I highlight the importance of understanding and leveraging the unique features of FastHTML for efficient web development. I also share my insights on the evolution of web development and the role of AI in shaping the future of coding practices.
Unpacking FastHTML Databases
October 08, 2024I explore the complexities of the FastHTML framework and its layered architecture, built on Python and Starlette. I discuss the challenges of adapting to new conventions while developing a Pythonic API wrapper and highlight the importance of understanding evolving frameworks for effective web development. I also delve into the intricacies of FastHTML's database features, including table creation, persistence, and user data management, emphasizing the importance of understanding these concepts for building robust web applications.
A ChatGPT o1-Preview Code Review
October 07, 2024I detail my experience building the next generation of Pipulate, a Python-based web application, using the FastHTML framework. I highlight the challenges I faced with HTMX and real-time streaming, and express my excitement about the potential for creating powerful, easily shareable local web apps with this technology.
FastHTML WebSockets & Database for Streaming & Persistence
October 06, 2024I discuss the challenges and benefits of transitioning to NixOS from traditional Linux distributions, highlighting the unique aspects of NixOS's filesystem hierarchy and package management. I explain the benefits of Nix's deterministic packaging system and how it can be leveraged on macOS and Windows using Nix Flakes. I also provide a step-by-step guide for getting started with Nix Flakes and emphasize the importance of embracing the NixOS philosophy for improved productivity and simplified software management.
Ollama Websocket Chat
October 05, 2024I detail my journey of building a reproducible development environment using Nix flakes, focusing on creating a "home" script to streamline setup across platforms. I discuss the challenges of managing dependencies and ensuring consistency across different operating systems, and I highlight the benefits of Nix's declarative approach and immutable store. I also share my experiences with web development frameworks and the importance of choosing the right tools for building modern web applications.
Understanding FastHTML's Framework Opinions
October 04, 2024I detail my experience transitioning to NixOS and using Nix flakes to create reproducible development environments. I discuss the challenges of managing dependencies and ensuring consistency across different platforms, and I highlight the benefits of Nix's declarative approach and immutable store. I also share my perspective on the evolution of web development and the importance of choosing the right tools and frameworks for building modern web applications.
From Jupyer Notebooks to FastHTML with WebSockets
October 03, 2024I've been working in Jupyter Notebooks for years and love the flexibility they provide, but collaborating and scaling projects with them can be a challenge. I'm excited to get back into web development with tools like FastHTML that simplify the process, and I'm particularly interested in using WebSockets to handle long-running tasks in my applications. My goal is to create a streamlined workflow that combines the rapid prototyping of Jupyter Notebooks with the power and accessibility of web applications, all while maintaining a clean and manageable codebase.
Code as Infrastructure
October 02, 2024In this article, I chronicle my journey of building a robust Nix Flake development environment that seamlessly works across macOS, Linux, and Windows WSL. I delve into the challenges of integrating CUDA support and specialized tools like JupyterLab, emphasizing the importance of a virtual environment for data science flexibility. Through a step-by-step account, I detail how I progressively enhanced the flake.nix to achieve a versatile and powerful development setup that liberates developers from hardware and platform constraints.
Melding a Mac and Linux Nix Flake
October 01, 2024In this article, I chronicle my journey creating a versatile, cross-platform development environment using Nix flakes. I delve into the intricacies of building a system that seamlessly integrates JupyterLab, CUDA for GPU acceleration, Ollama for running large language models locally, and a FastHTML server, all while ensuring compatibility across Linux and macOS. I also discuss the challenges encountered when working with cutting-edge technologies and how Nix's robust package management system helped me overcome them.
Forking a Flake of Infrastructure as Code
September 27, 2024I've finally cracked the code to a truly portable and reproducible development environment using Nix flakes! It was a wild ride wrestling with different technologies, but Nix was a lifesaver for managing dependencies and keeping things consistent across my Linux and Mac machines. I even found a way to seamlessly integrate AI-assisted coding tools like Cursor AI and Jupyter AI into the mix. The real kicker was building a FastHTML web app that taps into the Botify API – talk about a learning curve with that BQL language! But hey, who needs sleep when you're riding the wave of efficient and cutting-edge development?
There's No Home Like Nix
September 26, 2024In this article, I delve into building a Python web development environment within Nix, offering solutions for incorporating packages not readily available in the Nix repository. I guide you through using dotenv to securely manage environment variables and present a practical example of a simple FastHTML web application that prompts users for a secret and stores it safely. Additionally, I demonstrate the implementation of a basic chat server with Ollama, emphasizing the advantages of leveraging local LLMs for AI-assisted development.
The DevOps Renaissance: How Infrastructure as Code is Redefining Digital Craftsmanship
September 25, 2024I've rediscovered the joy of being a digital Renaissance person, thanks to Nix flakes! These little configuration files are like a Webmaster's toolkit for my development environment, giving me and my team the power to create consistent, cross-platform setups with GPU acceleration and easy customization. It's like having a digital multi-tool that keeps getting better with every tweak. Come along with me as I explore the ins and outs of Nix flakes with Claude 3.5 Sonnet and learn how to reclaim that holistic approach to development that I thought was lost in the age of hyper-specialization.
FastHTML and Cursor AI on Linux, Mac & Windows
September 24, 2024In this article, I share my adventure setting up a cross-platform development environment with Nix, featuring FastHTML and the AI-powered code editor, Cursor. It's a journey through the challenges of integrating cutting-edge technologies, highlighting the elegance of Nix's package management. I delve into configuring NixOS, wrangling Python virtual environments, and rigorously testing the setup across Macs, Windows (using WSL), and Linux to ensure compatibility. Ultimately, it's a testament to creating a reproducible and robust development experience that bridges the latest in AI-assisted coding with the power and flexibility of Nix.
Using NixOS and Nix with Pip Install DotEnv
September 23, 2024I detail my process of setting up a robust development environment using Nix flakes, incorporating JupyterLab, CUDA support, and a FastHTML server. I highlight the benefits of this approach for data science and web development, emphasizing the flexibility and adaptability it offers for various tasks and skill levels.
Getting My Nix System Together
September 22, 2024I detail my process of setting up a NixOS system and creating reproducible data science environments using Nix flakes. I explain my approach to configuring NixOS, including the use of a minimal configuration.nix file and the integration of essential services like Ollama and CUDA. I also discuss the benefits of using Python virtual environments within Nix flakes to manage Python dependencies and ensure flexibility for data science tasks.
Updating NixOS
September 17, 2024I share my experience transitioning to NixOS from traditional Linux distributions like Ubuntu and Fedora, highlighting the unique aspects of NixOS's filesystem hierarchy and package management. I explain the benefits of Nix's deterministic packaging system and how it can be leveraged on macOS and Windows using Nix Flakes. I also provide a step-by-step guide for getting started with Nix Flakes and emphasize the importance of embracing the NixOS philosophy for improved productivity and simplified software management.
Embracing AI-Assisted Development with Jupyter AI and Nix Flakes
September 16, 2024I detail the process of building a versatile flake.nix file for a consistent development environment across different platforms. Starting with a minimal setup, I progressively incorporate JupyterLab, CUDA support, and a FastHTML server, highlighting the flexibility offered by a virtual environment for installing additional packages. This approach ensures a robust and adaptable development experience for various data science and web development tasks.
Cross-Platform Nix Flake for Jupyter & FastHTML
September 15, 2024I detail building a versatile Nix flake for a consistent development environment across different platforms, starting with a minimal setup and progressively incorporating JupyterLab, CUDA support, and a FastHTML server. I highlight the flexibility offered by a virtual environment for installing additional packages, ensuring a robust and adaptable development experience for various data science and web development tasks.
Get the Big Tech Picture to Maintain Agency
September 14, 2024I explore the historical development of key technologies like Unix, C, Python, and Nix, highlighting their role in empowering individuals in a rapidly changing tech landscape. I emphasize the importance of mastering fundamental tools and concepts to maintain agency and independence in an AI-driven world. I also discuss the enduring relevance of the Unix philosophy and the benefits of open-source software and community collaboration. By understanding the evolution of these technologies, individuals can gain a deeper appreciation for their potential and leverage them to navigate the complexities of modern computing.
My First Nix Flake Will Be JupyterLab
September 13, 2024I explore creating a portable JupyterLab environment using Nix flakes, aiming to maintain consistency between my NixOS desktop and MacBook for SEO automation tasks. This setup, incorporating Jupyter AI and local LLMs, enables me to share a reproducible development environment with coworkers and streamline my workflow. The article highlights the benefits of Nix flakes for managing complex configurations and ensuring cross-platform compatibility, while emphasizing the importance of local-first development and open-source tools.
Getting Started with Nix Flakes
September 12, 2024This article describes my journey to integrate Nix Flakes into my NixOS configuration for better version control and reproducibility. Initially hesitant due to the perceived complexity, I eventually embraced Flakes for their ability to simplify git management and streamline my workflow. The article provides a step-by-step guide on implementing Nix Flakes, moving the system configuration to user space, and rebuilding the system for a more manageable and reproducible development environment.
Groking the NixOS Langauge
September 10, 2024This article explores the challenges a Python programmer faces when learning the NixOS system configuration language, which is based on functional programming principles. I seek to understand the declarative nature of Nix expressions, the syntax and semantics of the language, and the abstract data structures it employs. The article highlights the differences between Nix and imperative programming languages like Python, emphasizing the need for a shift in thinking to grasp the functional paradigm.
Linux, Python, Vim & Git (LPvg) Your Minimum Tech Toolkit for Life
September 09, 2024This 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.
Future-proof Your Tech Skills
September 08, 2024This article advocates for a "future-proof" approach to tech skills, focusing on mastering fundamental tools like Linux, Python, vim, and git (the "LPvg stack"). This approach emphasizes adaptability, independence, and long-term relevance in a rapidly changing technological landscape. It encourages professionals to develop technical skills as a complement to their domain expertise, enabling them to better serve clients and navigate the evolving world of AI and automation. The article also highlights the importance of clear communication protocols between humans and AI systems, as well as the benefits of leveraging local AI infrastructure for greater control and flexibility.
</ol>
---
