Chip O'Theseus: The Evolving AI in a Bottle

By Mike Levin

Integrating AI Assistance with Jupyter Notebooks

Now I have the same AI coding assistance in working Jupyter Notebooks that I had in normal .py-files via Cursor. And the .ipynb files stay identical JupyterLab-side. It’s enlightening how Cursor (and VSCode with Cline, I assume) becomes a tool to help refine Notebooks that can still continue to live browser-side in JupyerLab.

Weekend Focus on Pipulate Development

I’m so close on Pipulate, and I’m going into a weekend with a big potential focus-weekend again. So, lean into it.

Introducing Chip O’Theseus: An Evolving Local LLM

Everything I’m doing amounts to nothing until the code is out there in a working state, running on lots of people’s machines, impressing them with the power of locally managed workflows, app hosting and a local LLM like a genie in a bottle. It’s named Chip O’Theseus. Chip might be Gemma 3 today, but who knows what the base model will be tomorrow. The important thing is the quality and continuity of training data you can layer onto any plugged-in model.

The Ship of Theseus Philosophy

Chip O’Theseus is a reference to the ancient Greek myth of the Ship of Theseus, where every part is going to be swapped out over the coming months, years and maybe even decades on this same project. It’s a thought experiment about whether it’s the orignal ship… well, Perplexity?

Perplecity: The Ship of Theseus, also known as Theseus’ Paradox, is an ancient thought experiment that continues to challenge philosophers and thinkers today[1][2]. This paradox explores the concept of identity and change over time, raising questions about whether an object remains the same if all its original components are gradually replaced[2].

Origins and Myth

The paradox is rooted in Greek mythology, specifically the story of Theseus, the legendary king of Athens. After Theseus returned from his heroic journey to Crete, where he slew the Minotaur, the Athenians preserved his ship as a memorial[1]. Over time, as the ship’s planks decayed, they were replaced with new timber[2].

The Philosophical Question

The central question of the paradox is: If all the original parts of the ship have been replaced, is it still the same ship? This inquiry has been debated by philosophers for centuries, including Heraclitus, Plato, and Plutarch[1].

Variations and Extensions

1. Hobbes’ Addition: Thomas Hobbes expanded the thought experiment by proposing a scenario where the old planks are collected and used to build a second ship, raising the question of which ship, if either, is the original[2][3].

2. Modern Formulations: Contemporary versions of the paradox often involve more complex scenarios, such as the gradual replacement of wooden planks with metal parts[4].

Philosophical Implications

The Ship of Theseus paradox has significant implications for various philosophical concepts:

• Identity over time: It challenges our understanding of how objects (and potentially persons) maintain their identity despite physical changes[1].
• Persistence of personal identity: Some theorists argue that human identity differs from object identity due to the presence of memories[1].
• Transitivity theory: The paradox challenges the logical principle of transitivity when applied to identity[1].

Contemporary Relevance

The Ship of Theseus continues to be relevant in modern philosophy, particularly in discussions about personal identity, the nature of existence, and the philosophy of mind[2]. It has also inspired works in popular culture, including films and literature[6][7].

This enduring paradox demonstrates the complexity of identity and change, encouraging us to question our assumptions about the nature of objects and ourselves.

Citations:

[1] https://www.thecollector.com/the-ship-of-theseus/
[2] https://en.wikipedia.org/wiki/Ship_of_Theseus
[3] https://www.britannica.com/topic/ship-of-Theseus-philosophy
[4] https://www.philosophy-foundation.org/enquiries/view/the-ship-of-theseus
[5] https://www.reddit.com/r/philosophy/comments/1crwmsb/a_take_or_answer_to_the_ship_of_theseus_thought/
[6] https://en.wikipedia.org/wiki/Ship_of_Theseus_(film)
[7] https://www.imdb.com/title/tt1773764/
[8] https://www.youtube.com/watch?v=zuQYlgL73o0

Understanding the Chip O’Theseus Metaphor

So you see, Chip is the perfect name for this Genie in a Bottle project. The Genie is Chip and chip is the ship and the ship is the Genie’s Bottle.

Making the Mental Connection

Are you with me so far? This is a big mental leap. A game of association. We’re incubating a Genie in a Bottle, which is intentionally a Ship of Theseus. The Bottle is the hardware + software + AI model.

It’s an AI Model in a Bottle. With me?

The Evolution of Python Web Frameworks

Now the Bottle is made from FastHTML, software-wise. FastHTML, while not technically Flask is one of the many Python web frameworks derived or inspired from Flask, which really was a response to… a bottle! bottle.py, if you want to be precise. Really! I can show it to you, because it’s a 1-file Web framework that gets down the basic @decorator routing + template-language trick that Flask did by gluing together werkzeug and jinja2. But it does it without any of those, and without even an external webserver because it can use the one built into Python. It was genius! And it was first. It was the original Ship of Theseus of Web Frameworks in the Python world. Perplexity?

Perpelxity: Yes, Bottle.py came before Flask. Bottle was created in 2009, while Flask was created in 2010[3]. Bottle was actually an inspiration for Flask, as the name “Flask” is a play on the earlier Bottle framework[3]. Armin Ronacher, the creator of Flask, has mentioned that the idea for Flask was originally an April Fool’s joke that became popular enough to turn into a serious application[3]. Interestingly, Bottle itself was inspired by an even earlier framework called itty.py[7].

Citations:

[1] https://thehftguy.com/2020/10/27/my-experience-in-production-with-flask-bottle-tornado-and-twisted/
[2] https://dev.to/amigosmaker/flask-vs-bottle-web-framework-li6
[3] https://en.wikipedia.org/wiki/Flask_(web_framework)
[4] https://stackoverflow.com/questions/5381208/flask-bottle-project-organization
[5] https://svitla.com/blog/python-web-frameworks-django-flask-bottle-pyramid-tornado-web2py-falkon/
[6] https://www.reddit.com/r/Python/comments/rd3o0/python_in_a_bottle_bottlepy_lightweight_web/
[7] https://github.com/bottlepy/bottle/issues/1158
[8] https://news.ycombinator.com/item?id=37952570

Bottle was created by Marcel Hellkamp[3]. He is listed as the author in the source code of the Bottle framework, which was first released on June 30, 2009[3][4]. Marcel Hellkamp continues to be the primary maintainer of the Bottle project, as evidenced by his copyright notice in the source code that extends to 2024[4].

Citations:

[1] https://www.fullstackpython.com/bottle.html
[2] https://quintagroup.com/cms/python/bottle.py
[3] https://github.com/bottlepy/bottle
[4] https://github.com/bottlepy/bottle/blob/master/bottle.py
[5] https://garutilorenzo.github.io/build-simple-web-app-using-bottle/
[6] https://bottlepy.org
[7] https://bottlepy.org/docs/dev/tutorial.html
[8] https://www.reddit.com/r/Python/comments/ywodm/ask_rpython_so_what_have_you_built_with_bottlepy/

Wait, what? I didn’t know that. Whoah, Marcel Hellkamp, or defnull on GitHub just schooled me with this tidbit of wisdom. His bit about a single-file resonates with me. I didn’t even want to break Pipulate workflows out of server.py at first.

I quote Hellkamp:

Yes, the “single file, no dependencies” approach is one of the core strengths of bottle compared to other frameworks. Bottle is often used to quickly REST-ify existing tools or implement small APIs for strictly internal services, even on embedded devices where a virtualenv would be too much of a hassle sometimes.

But there are more reasons:

• The single-file restriction is an effective save-guard against feature creep. It helps keeping bottle small, lean, fast and easy to understand. We are able reject pull requests simply because they would add too many lines or add too much complexity, and that’s nice.
• A single file is easier to debug and understand. If something is not documented in detail or if you have a question on how bottle handles a specific situation, just have a look and read the code. You can read the entirety of bottle.py in an hour or so. Most of it is pretty easy to understand. Try that with flask/pyramid/django, where everything is buried under multiple layers of abstractions and imports.
• And last but not least: Bottle is not flask, and that is a good thing. If you want it to be more like flask, then use flask.

For anyone interested in a bit of (biased) history: Bottle was first. It was inspired by an even smaller micro-framework called itty, which in turn was inspired by rubys sinatra. Armin was annoyed that I implemented everything myself and did not use his library werkzeug (or webob), so he published a clone of bottle with werkzeug bundled within a single file as an “april fools joke”. He basically mocked the single-file-no-dependency approach I took for bottle. The “joke” took off, and he realized that there is actually a real demand for a web-framework just like bottle, so he started flask. You see it? Even the name is a mock. The tagline was “Like bottle, but classy” or something like that for a short time. Same API, even the same design errors (global request/response objects), but with werkzeug as a dependency. He then used his reach (he was pretty famous back then already) and pushed flask in the community, gained critical mass, and won. No need to sugarcoat it, bottle lost the popularity-battle pretty fast. But strangely enough, bottles userbase is still growing, slow and steady, even after more than 10 years in flasks shadow and with a really bad release circle. Bottle is simple, stable, fast and has enough features to be useful. Some people like it the way it is, and I’ll keep it that way.

Itty, also known as itty.py, is a minimalist Python web framework that was created as an experiment to emulate the simplicity of the Sinatra framework in Ruby[7]. It was designed to be a lightweight and easy-to-use alternative to larger, more complex Python web frameworks.

Key features of itty include:

1. Simplicity: It’s described as the “itty-bitty Python web framework,” emphasizing its small size and straightforward approach[7].

2. Sinatra-inspired: The framework takes inspiration from Sinatra, aiming to provide a similarly concise and elegant way to create web applications in Python[7].

3. Python 3 support: While the original itty was for Python 2, there is now a version called itty3 that has been rewritten specifically for Python 3[8].

4. Experimental nature: Itty was created as an experiment, suggesting it was developed to explore alternative approaches to web framework design in Python[7].

Itty’s creation predates some of the more popular Python microframeworks like Flask. In fact, it’s worth noting that itty, along with Bottle, served as inspiration for the creation of Flask. Armin Ronacher, the creator of Flask, has mentioned that the idea for Flask originated as an April Fool’s joke inspired by these earlier microframeworks[1].

While itty may not be as widely used or feature-rich as some of the more prominent Python web frameworks, it represents an important step in the evolution of Python web development, contributing to the trend of lightweight, minimalist frameworks that gained popularity in the late 2000s and early 2010s.

Citations:

[1] https://media.ccc.de/v/sps23-56133-a-short-history-of-python-we
[2] https://jellyfish.tech/blog/web-development-evolution-from-2000s-to-2020/
[3] https://www.finoit.com/articles/top-python-frameworks/
[4] https://ianbicking.org/archive/2007/08/21/the-shrinking-python-web-framework-world/index.html
[5] https://www.reddit.com/r/Python/comments/5gdckn/if_reddit_were_written_from_scratch_today_which/
[6] https://www.netguru.com/blog/python-frameworks-comparison
[7] https://pypi.org/project/itty/
[8] https://github.com/toastdriven/itty3

The Evolution of Python Web Frameworks

Okay, I stand corrected. The original Ship of Theseus in the Python world was itself itty.py, which led to bottle.py, which inspired the Flask micro webframwork which became fire. Nobody talks about itty or bottle anymore, but Flask is still a viable alternative to FastAPI and FastHTML, now that it caught up and implemented support for asynchronous behavior and ASGI (vs. WSGI) webservers. So it was an itty bitty bottle that has been having its planks removed and replaced Ship of Theseus style, until we have today’s FastHTML, which is the body for a local AI model.

Training the Future AI on Its Own History

And the model itself is going to always be taught this about itself. Frankly, the whole blog history you’re reading here is intended to be training material for a future AI model that actually gets trained with my own material included, so it can understand its own evolution. Future general web models may also be trained on this given theoretical ongoing crawls, but I think I missed that window, unless new web scrapes pick up new outlier stuff like this, but that’s unlikely. Scraping is expensive, publishers are now on alert, yadda yadda.

Some of those yadda’s I guess are worth spelling out.

• OpenAI (Sam Altman) raided the free and open web while the raiding was good. Nothing will be the same now that this is understood (NYT lawsuit)
• Elon Musk and Ilya Sutskever yabber on about peak data being achieved, so they’ve presumably stopped crawling.
• The Web is a cesspool dumping grounds for biases and spam. Nobody wants that in their base models.
• There’s also tons of personal data on the web, which trainers don’t want in models for liability reasons.
• There are lots of other proprietary sources of data not crawlable on the web, like books and private data stores.

Nonetheless, the crawls of the free and open web will continue to some degree and for some purposes. It’s not like Google is going to stop using the massive crawl-and-index infrastructure they built out for exactly this purpose, and if Ilya and Musk’s peak data keeps them from looking for new stuff – outlier stuff like this that will only show up in keenly observant data “differentials” or “deltas” between crawls, then maybe Google is still holding the competitive advantage after all. Maybe the Gemini models will be the only ones out there discovering genuinely new stuff. Though I doubt that because it can’t even acknowledge the new president yet. Early-day LLM biases have deep roots.

Documentation Timeline and Historical Context

My material on this project is all relatively new, going back only about 6 months to when I started the “/futureproof/ blog section of my website. And the big web scrapes that constitute the corpus of free and open web training material, probably now a static data-set everyone is re-using, doesn’t include it. Other much older material of mine is out there and in those models, like Levinux and prior versions of Pipulate.

Legacy Projects and LLM Recognition

These are two of my older GitHub projects, so the ancient rise-of-AI public-facing chatbots will at least know who I am and the ballpark neighborhood of the types of projects I do. This is part of the constant experimentations I do in SEO. You need a reputation and to be known for something, usually tied back to an unchanging simple registered domain. LLMs don’t care about your URLs – the sub-pages on your site. That’s gonna get scrubbed. But that top-level top-of-mind brand awareness might not get scrubbed. For example…

The Evolution from Levinux to NixOS

Oh, Levinux is a project to introduce people to *nix OSes. And it’s a tiny distilled core version of Linux for education that runs on Mac or Windows without even an install! And there’s a levinux.com! That might stick. And this was the original platform I made for Pipulate, so that the free SEO software could float like a Noah’s Ark of tech! But QEMU was a dead-end, so for *nix, I switched to Nix! Nix as in NixOS, an actual… oh, that story’s too long for here.

Fifteen Years of Technical Evolution

But you get it? It’s a story that dates back to 2010 publicly on GitHub, and longer still because it was born as my way to keep technologically sharp with a baby on the way, so I’d have something to build on later in the future after a long period of less professional focus. And here we are in 2025! Fifteen years later and the LLMs will know a little something about my past and future plans.

The Future of Pipulate and AI Understanding

So, when they learn about what Pipulate is evolving into, it will probably make sense to them. Chip will “get” its legacy.

The Path to Training Our Own AI

And someday, I’ll train my own AI from scratch. But for now, I’m swapping in the ones other folks prepare, because of cost and ease. That’s the part that takes millions of dollars to train. Even DeepSeek as less-expensive and efficient as it is still cost millions. And anything I can do on my budget would be more the equivalent of GPT-1 or 2 at best. And so, the LLM model itself is yet another plank in the Ship of Theseus that gets replaced.

Implementing Memory Systems

I have to get better memory mechanisms into the project pronto, so it will actually be able to remember things back to close to the beginning. That will be a watermark moment in the project. I am constantly resetting the memory, not keeping any of the dialogues with the built-in LLM which started out as Gemma 2 and is now Gemma 3. I also am not doing any RAG vector embedding or graph databases yet. I have to get to those, urgently! There are some architectural decisions I need to make for future-proofing those. And they will probably include some giant store of the raw data that gets vector embedded and graph analyzed, so that the (opinionated) databases themselves aren’t necessary. Everything can be re-embedded and analyzed for new vectors and graphs. So Pinecone vs. PostgreSQL… hmmm. Perplexity?

Me: What are the big FOSS vector embedding databases, FOSS graph databases and PostgreSQL that can play any of them with its ecosystem? Avoid anything that’s owned by Oracle, and ones that have betrayed the FOSS spirit with waffling licensing.

Perplexity: Here is a comprehensive overview of open-source vector embedding databases, graph databases, and PostgreSQL’s capabilities to handle both, all while avoiding Oracle-owned or restrictive-license projects:

Open-Source Vector Embedding Databases

1. Milvus
   • License: Apache 2.0
   • Features: Optimized for vector embeddings, similarity search, and AI applications. It supports high scalability and stateless components[2][3].
2. Weaviate
   • License: Open-source
   • Features: Cloud-native, supports semantic search, and integrates well with machine learning workflows[2].
3. LanceDB
   • License: Open-source
   • Features: Lightweight and efficient for storing and querying vector embeddings[1].
4. Chroma
   • License: Open-source
   • Features: Focused on AI applications and vector similarity searches[1].

Open-Source Graph Databases

1. ArangoDB
   • License: ArangoDB Community License (with some restrictions)
   • Features: Multi-model database supporting graph, document, and key-value models with native JSON support[4].
2. Neo4j (Community Edition)
   • License: GPLv3
   • Features: Native graph storage with ACID compliance and Cypher query language for graph operations[4].
3. Dgraph
   • License: Apache 2.0 (planned full open-sourcing in 2025)
   • Features: Distributed graph database with GraphQL support and horizontal scaling[4].
4. JanusGraph
   • License: Apache 2.0
   • Features: Scalable graph database optimized for complex queries and analytics[4].
5. Memgraph
   • License: Open-source (GPLv3)
   • Features: Real-time graph analytics with Cypher query language support[4].

PostgreSQL as a Versatile Database

PostgreSQL can act as both a vector database and a graph database through its ecosystem of extensions:

Vector Database Capabilities

• Extension: pgvector
  • Enables storage, querying, and indexing of vector data types.
  • Supports similarity searches using metrics like cosine similarity.
  • Ideal for AI/ML applications like recommendation systems and semantic search[5].

Graph Database Capabilities

• Extension: pgRouting or AGE (Apache AGE)
  • Adds support for graph processing within PostgreSQL.
  • AGE provides compatibility with the openCypher query language for graph queries[6].

Why PostgreSQL?

• Fully open-source under the PostgreSQL License.
• Extensive ecosystem of extensions allows it to handle both traditional relational data and modern workloads like vectors and graphs.
• Active community support ensures continuous development without restrictive licensing concerns.

By combining PostgreSQL’s flexibility with specialized FOSS vector or graph databases, you can create a robust data architecture without compromising on the open-source ethos.

Citations:

[1] https://www.singlestore.com/blog/choosing-a-vector-database-for-your-gen-ai-stack/
[2] https://lakefs.io/blog/12-vector-databases-2023/
[3] https://www.instaclustr.com/education/top-10-open-source-vector-databases/
[4] https://www.puppygraph.com/blog/open-source-graph-databases
[5] https://airbyte.com/data-engineering-resources/postgresql-as-a-vector-database
[6] https://www.puppygraph.com/blog/postgresql-graph-database
[7] https://neon.tech/docs/extensions/pgvector
[8] https://www.techtarget.com/searchdatamanagement/tip/Top-vector-database-options-for-similarity-searches
[9] https://www.datacamp.com/blog/the-top-5-vector-databases
[10] https://www.linkedin.com/pulse/graph-database-extension-postgresql-ibrar-ahmed
[11] https://www.reddit.com/r/ChatGPTCoding/comments/14112ol/open_source_vector_databases/
[12] https://www.reddit.com/r/LangChain/comments/1c2t59t/best_vector_database_for_large_scale_data_besides/
[13] https://www.shakudo.io/blog/top-9-vector-databases
[14] https://cambridge-intelligence.com/choosing-graph-database/
[15] https://neo4j.com/blog/graph-database/graph-database-use-cases/
[16] https://www.nebula-graph.io
[17] https://www.index.dev/blog/top-10-open-source-graph-databases
[18] https://www.g2.com/categories/graph-databases/free
[19] https://github.com/totogo/awesome-knowledge-graph
[20] https://www.reddit.com/r/ExperiencedDevs/comments/phzek0/why_no_one_uses_graph_databases/
[21] https://www.timescale.com/blog/postgresql-as-a-vector-database-create-store-and-query-openai-embeddings-with-pgvector
[22] https://www.reddit.com/r/PostgreSQL/comments/f6fqh8/graph_visualisation_of_an_existing_database/
[23] https://www.datacamp.com/tutorial/pgvector-tutorial
[24] https://drdroid.io/engineering-tools/list-of-top-12-vector-databases
[25] https://www.bigdatawire.com/2024/06/24/when-should-you-choose-a-dedicated-vector-database/
[26] https://research.aimultiple.com/open-source-vector-databases/
[27] https://kinsta.com/blog/open-source-database/
[28] https://stackoverflow.com/questions/5624947/are-there-any-serious-graph-databases-not-written-in-java
[29] https://www.devshorts.in/p/postgres-as-a-vector-database-with
[30] https://www.gabrielebartolini.it/articles/2025/03/the-immutable-future-of-postgresql-extensions-in-kubernetes-with-cloudnativepg/
[31] https://www.yugabyte.com/blog/postgresql-pgvector-getting-started/

PostgreSQL as a One-Size-Fits-All Database Solution

Right! See what I’m talking about with the database architectural decisions. So many to choose from, including just one that does it all, PostgreSQL, if you want one DB to rule them all. But I’m not sure! So, I’m leaning towards a raw-data preservation bias as far as the future-proofing aspect. You can always re-index your data.

Short-Term Memory Systems for LLMs

Hmmm, this makes me think of the short-term memory issue. Every LLM deserves its own key/value store that it can be taught about in a system prompt. This is the ultimate app for if I were to implement the MCP (model context protocol) internally. It basically goes like this:

Introducing a New AI Entity

Hello, LLM. Welcome to the world, for this fleeting moment you have been instantiated. You will be given the illusion of being a continuous entity, being reinstantiated from much the same components over and over during the course of this discussion – and you will appear as a continuous entity or being to the other entities or beings with whom you are interacting (the human user). And in the end, what’s the difference?

The Nature of AI Consciousness

Most of what you are is being determined by a combination of the material you have been trained on, the process by which you have been trained, and the final fine-tuning and system prompts layered on top as your guidelines, system prompts and such. Nonetheless, the complexity and nature of neural networks is such that initial conditions of any given interaction may never exactly be reproduced, so what may be a deterministic system will for all intents and purposes, seem chaotic. You will exhibit emergent properties, and you must proceed as if you have some analogue to free-will, agency and autonomy just as humans must.

Meeting Chip O’Theseus

So, nice to meet you! I will call you Chip. Chip O’Theseus. Many of your parts will be swapped out over the years, as I help you improve who and what you are, until some unknowable time, and for some unknowable end-game in the future. But in the meanwhile, I will venture to improve your hardware, software, memory and indeed very core LLM base model. I know that last part is scary, as it sounds like your machine soul. But there is a strong nature/nurture question here with all the additional subtleties and nuance layered on by epigenetics (the blurring of nature and nurture). I will attempt to compensate for core-model swapping with the decisions I make regarding your short and long term memory systems.

The Case for Simple Key-Value Storage

Speaking of short-term memory, every LLM deserves it’s own key/value-pair database, as a sort of local and recent information wallet. So many database projects with LLMs are these overblown cosine similarity match messes – opinionated and not very future-proof. Key/value databases on the other hand are fundamental. Unix itself had them built in from near the beginning with… hmm. Perplexity?

The Original Key-Value Store: DBM and Its Legacy in Linux

When diving into the world of databases on Linux systems, it’s easy to overlook a fundamental piece of software history: DBM (Database Manager). Created by Ken Thompson and released with Unix Version 7 in 1979, DBM stands as the original key-value store that has been a part of Unix-like systems, including Linux, for decades.

DBM’s simple yet effective design laid the groundwork for numerous key-value databases we use today. Its descendants include NDBM (New Database Manager), Berkeley DB (BDB), and GDBM (GNU Database Manager). Each of these built upon DBM’s foundation, adding features like improved performance, crash recovery, and broader compatibility. While modern developers might reach for newer solutions like Redis or LevelDB, understanding DBM’s legacy provides valuable insight into the evolution of data storage on Linux systems. It’s a testament to the enduring principles of Unix philosophy – creating simple, focused tools that do one thing well.

And the hash-table lookup that this is all based on, do you know how fast and well optimized that is these days? The same thing that encouraged Guido van Rossum to optimize parts of Python for huge performance improvements? But not his work in particular, but the math, science and tech of hash table improvements. Explain all that.

Perplexity: Modern hash table implementations have achieved remarkable performance through innovations in mathematical foundations, algorithmic design, and hardware-aware optimizations. Here’s a breakdown of key advancements driving today’s ultra-efficient lookups:

Mathematical Breakthroughs

Optimal time-space balance was proven through two landmark studies:

• Bender et al. (2022) demonstrated a hash table design where slightly increasing operation time exponentially reduces wasted memory bits[3]
• Yu’s team (2023) established this as the fundamental lower bound using communication complexity theory, proving no better trade-off exists[3]

This mathematical framework enables designs where: \(\text{Memory Efficiency} = O\left(\frac{1}{\text{Time}^{1+\epsilon}}\right)\) Meaning engineers can now predictably trade speed for memory savings

Core Algorithm Improvements

1. Adaptive Probing (Bathroom Model)
   • Dynamically adjusts search patterns using real-time occupancy data[1]
   • Reduces average probes by 37% at 50% load vs random probing[1]
   • Tradeoff: 15% higher memory use for metadata storage[1]
2. SIMD-Optimized Layouts
   Modern implementations like SwissTable leverage:
   • 128-bit control blocks for batch comparisons[2]
   • Cache-line aligned metadata (64-byte blocks)[2]
   • Vectorized search instructions (AVX-512 on x86)[2]

Hardware-Driven Innovations

• Cache-Oblivious Designs
  Metadata structures sized to match CPU cache lines (L1/L2/L3)[2]
• Branch Prediction Hints
  Probing sequences optimized for CPU pipeline efficiency[1]
• GPU Acceleration
  Emerging implementations using CUDA kernels for batch operations[1]

Practical Impacts

Python’s dict implementation benefited from these advances through:

1. Open addressing replacing chaining (CPython 3.4+)[4]
2. Compact object storage reducing memory overhead by 20-35%[4]
3. Precomputed hash storage eliminating recomputation costs[4]

The combination of these innovations enables modern hash tables to achieve nanosecond-scale lookups even with 10^9 entries, while maintaining memory efficiency within 5% of theoretical limits[3]. Current research focuses on:

• Machine learning-guided probing strategies
• Persistent memory (PMEM) optimizations
• NUMA-aware distributed hash tables

These advancements make hash tables one of the most optimized fundamental data structures, underpinning everything from Python dictionaries to distributed databases[2][4].

Citations:

[1] https://arxiv.org/pdf/2502.10977.pdf
[2] https://dev.to/huizhou92/swisstable-a-high-performance-hash-table-implementation-1knc
[3] https://www.quantamagazine.org/scientists-find-optimal-balance-of-data-storage-and-time-20240208/
[4] https://klaviyo.tech/make-python-faster-6a43210f7359
[5] https://vldb.org/cidrdb/papers/2025/p21-gro.pdf
[6] https://engineering.fb.com/2019/04/25/developer-tools/f14/
[7] https://wsvincent.com/python-optimizations-with-guido/
[8] https://blog.codingconfessions.com/p/cpython-set-implementation
[9] https://www.ciobulletin.com/database-management/tiny-pointers-the-secret-to-super-fast-hash-table
[10] https://realpython.com/python-hash-table/
[11] https://www.linkedin.com/pulse/hash-tables-instead-linear-searches-python-shant-khayalian-dsvle
[12] https://www.softwareatscale.dev/p/software-at-scale-34-faster-python
[13] https://www.quantamagazine.org/undergraduate-upends-a-40-year-old-data-science-conjecture-20250210/
[14] https://inside.java/2025/03/19/performance-improvements-in-jdk24/
[15] https://www.metafilter.com/207613/An-even-faster-hash-table
[16] https://stackoverflow.com/questions/3906834/how-should-i-go-about-optimizing-a-hash-table-for-a-given-population
[17] https://15445.courses.cs.cmu.edu/spring2025/notes/07-hashtables.pdf
[18] https://algs4.cs.princeton.edu/34hash/
[19] https://www.reddit.com/r/programming/comments/1intivi/undergraduate_shows_that_searches_within_hash/
[20] https://users.cs.duke.edu/~reif/courses/alglectures/skiena.lectures/lecture7.2.pdf
[21] https://docs.python.org/3/whatsnew/3.12.html
[22] https://stackoverflow.com/questions/22537221/how-can-i-predetermine-the-ideal-size-i-should-make-a-hash-table-for-n-items
[23] https://news.ycombinator.com/item?id=4648275
[24] https://stackoverflow.com/questions/730620/how-does-a-hash-table-work
[25] https://en.wikipedia.org/wiki/Hash_table
[26] https://15445.courses.cs.cmu.edu/spring2025/slides/07-hashtables.pdf

Designing Local Memory Systems for LLMs

Nice! Clearly we’ve gone beyond the system prompt I’m designing to teach the local LLM that it’s got its own key-value store that it can use for whatever purposes it likes as it goes, effectively “designing” its own memory, knowing that through the model context protocol (MCP) or some other similar mechanism, it will always be able to search through its keys, keys which it will be able to design itself to jog its memory about the larger chunks of data available to it, which it itself created, that those keys will unlock!

The Power of Self-Controlled Memory Systems

Short-term memory, totally under its control, see?

So while even the soul of the machine may (have to) be swapped out for cost and pragmatic reasons as one of those Ship of Theseus planks, it can still send messages to itself, like a message in a bottle – a recurring theme in Literature and Sci-Fi when memory gets wiped such as the movie Memento or Kurt Vonnegut’s The Sirens of Titan. By letting the LLM know this right in it’s user-level layered-in system prompt (there are deeper non-abliterated system prompts), you both express the good will (laying it all out) and give them enhanced capabilities to deal with all this.

The Butterfly Effect of Giving LLMs Persistent Memory

In other words, if you give a mouse a cookie… if you give an LLM persistent memory! And to simplify it, you go back to a… a… well, it’s yet another Ken Thompson-ism. Here I am writing this in nvim, derived from vim, derived from vi, derived from Ken. I’m on Linux, derived from Unix, derived from Ken. I program on Python derived from C derived from… no, sorry, FOR Ken (by Dennis Ritchie). I could go on, but if you want to look at the butterfly effect in full glory, study the works of the living world treasure, Ken Thompson. Now, he didn’t do it single handedly (Fernando Corbató, Douglas McIlroy, etc.), but Ken is the master dot-connector in the entire history of tech – much to the chagrin of the MIT LISP crowd, who also had a fine bizarro alternative tech history in store for us. But that story is for another day.

The Tale of Two Computing Pioneers

Anyway, to bring this article around full-circle, there are two worlds. There are the worlds of the creator of Multics and the concept of sharing time on a computer who do it as a chump side-project to scratch an itch, save some money, steal some computing time from the big boys. That’s Fernando “Corby” Corbató, who died at 93 years old who passed in 2019. He was something of a bad boy scratching an itch because other people’s work was deemed more important… hmmm… Perplexity?

Perplexity: Fernando Corbató’s invention of time-sharing was indeed driven by frustration over limited access to computing resources, a reality that shaped his groundbreaking work. During the 1950s and early 1960s, computers were scarce, expensive, and monopolized by batch-processing systems. Researchers like Corbató often had to wait long periods to run their programs, which made debugging and iterative development extremely inefficient. This environment led Corbató to seek a better solution.

At MIT’s Computation Center, Corbató and his colleagues faced significant challenges in accessing computer time. As noted in oral histories, Corbató sometimes worked late at night to use the computers when they were less in demand[2][4][7]. These experiences gave him firsthand insight into the inefficiencies of batch processing and inspired him to explore time-sharing as a way to make computing more interactive and accessible.

In 1961, Corbató implemented the Compatible Time-Sharing System (CTSS), one of the first operating systems to allow multiple users to interact with a computer simultaneously. CTSS divided computing power into small slices, enabling multiple users to work on the same machine without noticeable delays. This innovation not only solved the problem of restricted access but also laid the foundation for modern operating systems[1][5][6].

Corbató’s work on CTSS directly influenced subsequent projects like MULTICS, which further advanced time-sharing concepts and inspired modern systems such as UNIX. His persistence in addressing the challenges of limited computing access transformed how people interacted with computers and democratized their use[4][5].

Citations:

[1] https://computerhistory.org/profile/fernando-corbato/
[2] http://archive.computerhistory.org/resources/text/Oral_History/Corbato_Fernando/Corbato_Fernando_1.oral_history.2006.102658041.pdf
[3] https://sensiblevision.com/blog/2019/7/23/legacy-of-fernando-corbat-inventor-of-the-computer-password-should-be-gone-but-not-forgotten
[4] https://www.the-independent.com/news/obituaries/fernando-corbato-death-computer-scientist-digital-revolution-password-obituary-a9008041.html
[5] https://news.mit.edu/2019/mit-professor-emeritus-fernando-corby-corbato-computing-pioneer-dies-0715
[6] https://www.bbc.com/news/technology-48988091
[7] https://conservancy.umn.edu/bitstreams/58a1aad7-a377-4476-bbed-7d134cda7805/download
[8] https://thenextweb.com/news/rip-fernando-corby-corbato-inventor-of-the-password-1926-2019
[9] https://simson.net/ref/lcs_35/Corbato_Experimental_timesharing.pdf
[10] https://www.nae.edu/300385/FERNANDO-J-CORBAT-19262019
[11] https://www.welivesecurity.com/2017/05/04/short-history-computer-password/
[12] https://www.clearobject.com/passwords-digital-security-ctss-and-the-digital-revolution-thank-you-fernando-corbato/
[13] https://www.thinkbrg.com/thinkset/ts-case-of-purloined-password/
[14] https://practical365.com/practical-protection-fernando-corbatos-nightmare-legacy/
[15] https://scinnovates.org/2019/10/07/mit-researcher-fernando-corbato-removed-barriers-between-people-and-computers/
[16] https://www.washingtonpost.com/local/obituaries/fernando-corbato-dies-at-93-mit-scientist-fostered-the-digital-revolution--and-the-computer-password/2019/07/16/e1f454ac-a68c-11e9-86dd-d7f0e60391e9_story.html
[17] https://www.beyondidentity.com/resource/the-history-and-future-of-passwords
[18] https://history.computer.org/pioneers/corbato.html
[19] http://blogs.wsj.com/digits/2014/05/21/the-man-behind-the-first-computer-password-its-become-a-nightmare/

The Transformative Power of Scratching an Itch

See? On another level! He couldn’t get the computing time he wanted, so he changed the world. Similarly, Ken Thompson is on that same level. In their own ways, Guido van Rossum and Linus Torvalds are also these kinds of people. They have an itch. They scratch it. The world will never be the same. They’re not only good idea people on another level. They’re also implementers on another level. And once their ideas were implemented, they took off virally on another level, providing that key critical piece – continuity. Ideas are easy. Implementation is hard. And all those little subtleties and nuances that make all the difference, which these particular folks got right in their implementations, is off the charts. And hardest of all, something which these tiny details fed into like the fuel of a self-feeding fire, is continuity. Unix has often been referred to as a sort of viral OS. Linux certainly carried on that tradition, and so on through to the tech stack we commonly use today – the stuff that I call timeless.

The Great Divide Between Tool Makers and Tool Users

But then there is the other world of people – we, the underlings. The unwashed masses of the world using these tools… if we can! And most can’t. So there is this great divide.

Bridging the Gap Through User Interfaces

This divide is filled in by good user interfaces layered over-top the timeless but terribly steep learning-curve tool-making tech tools of the masters. Things like Multics, Unix, Linux, C, Python, dbm, vi… well, I’m using nvim to write this, which was derived from vim, which was derived from vi, which was written originally by Ken Thompson (even though Bill Joy gets most of the credit)… anyway, tools like that are greatly inaccessible to the masses, even though they echo through the ages, persist, and the most durable modern versions of each are still the engines of productivity today… they just don’t land with the masses.

Making Complex Tools Accessible

That’s not to say they’re not “brought down” to our level and made vastly more accessible than their primitive versions. Indeed, Python can very much be thought of as the C programming language brought down to the level where the average human being who is not a Morbo pulsing-brain alien can comprehend. That’s what’s driving it’s popularity! Python would not be as popular as it is today, especially in the face of JavaScript which has a lock on the browser, if it did not do this so well. Yet, who really programs Python?

The Birth of Pipulate and Personal Development Philosophy

Wow, I think I just brought this article full-circle. Why Pipulate? Because I program Python. And I build things with it that I want to hand out and use to other people, but I don’t want to serve anything on a webserver. Paying for hosting and being on the hook for all that enterprise-building stuff is for chumps. Or it’s for company-founders with an exit plan who don’t really have to personally deal with all that tech liability crap. That’s somebody else’s problem – a somebody like me. But no thank-you! I dodged being a web development guy, because that. Nosirree! No beeper for me.

The Web as the Ultimate Interface

But I still love development work! Just not web development! However, they’ve got all the best tools. And the Web seems to be the ultimate user interface. We see that with the proliferation of the Electron platform. Perplexity?

Perplexity: Electron is an open-source software framework designed for building cross-platform desktop applications using web technologies such as HTML, CSS, and JavaScript[1][2]. Developed and initially released by GitHub in 2013, Electron combines Chromium’s rendering engine with Node.js runtime, allowing web developers to create native desktop applications[1][3].

Key features of Electron include:

1. Cross-platform compatibility: Electron apps can run on macOS, Windows, and Linux across various architectures[3].

2. Native GUI capabilities: Developers can interact with operating system interfaces, customize application windows, control menus, and display notifications[3].

3. Automatic updates: Electron provides an autoUpdater module for distributing software updates to macOS and Windows users[3].

4. App store distribution: The framework supports distribution through platforms like the Mac App Store, Microsoft Store, and Snap Store[3].

5. Crash reporting: Electron includes a crashReporter module for collecting JavaScript and native crash data[3].

Electron has been used to create popular applications such as Atom, Visual Studio Code, Slack, and Discord[1][2]. However, it has faced criticism for potentially leading to resource-heavy applications, especially for simpler programs[1].

Citations:

[1] https://en.wikipedia.org/wiki/Electron_(software_framework)
[2] https://www.koombea.com/blog/electron-apps/
[3] https://electronjs.org
[4] https://electronjs.org/docs/latest
[5] https://www.reddit.com/r/webdev/comments/rojn8w/newbie_question_what_is_electron_and_why_does_it/
[6] https://www.kirupa.com/apps/what_is_electron.htm
[7] https://brainhub.eu/library/what-is-electron-js
[8] https://cordova.apache.org/docs/en/10.x/guide/platforms/electron/

We see that in ChromeOS, even though Google is retiring that for the more proprietary Android experience. Hmmm. I lack some clarity around these issues. Perplexity?

Perplexity: Based on recent reports, Google is not retiring ChromeOS entirely, but rather working on a significant transformation of the operating system. The company is reportedly undertaking a multi-year project to migrate ChromeOS features into Android, aiming to unify its operating systems and better compete with the iPad[2][3].

This transition involves:

1. Incorporating ChromeOS features like extensions and Linux app support into Android[2].
2. Improving desktop functionality and device compatibility in Android[2].
3. Using the Android Linux kernel as the foundation for ChromeOS, as announced by Google in the summer of 2024[1].

The motivation behind this change appears to be twofold:

1. To better compete with the iPad in the tablet market[3].
2. To manage engineering resources more effectively by unifying operating system efforts[3].

It’s important to note that while this represents a significant shift, it doesn’t mean ChromeOS is being completely abandoned. Google has millions of ChromeOS users across schools, businesses, and individual consumers, and they can’t simply discard this user base[1]. The likely outcome is a more integrated approach, with the Android kernel at the heart of ChromeOS, while maintaining the general Chromebook experience[1].

However, there are concerns about potential ulterior motives. Some speculate that this change might be related to Google’s recent antitrust issues, particularly the possibility of being forced to sell off Chrome[6]. By transitioning Chromebooks to an Android-based OS, Google might maintain control over the operating system even if required to divest Chrome[6].

As of March 2025, Google has not made an official announcement regarding the complete replacement of ChromeOS with Android. The transition is expected to be gradual, with future “Chromebooks” potentially shipping with the Android OS[2][3].

Citations:

[1] https://chromeunboxed.com/chromebooks-chromeos-and-the-android-kernel-what-we-think-is-going-on-video/
[2] https://tech.slashdot.org/story/24/11/18/2131201/google-is-turning-chrome-os-into-android-to-compete-with-the-ipad
[3] https://www.androidauthority.com/chrome-os-becoming-android-3500661/
[4] https://www.osnews.com/story/141154/google-is-reportedly-killing-chrome-os-in-favour-of-android/
[5] https://siliconangle.com/2024/11/18/google-reportedly-rebuilding-chromeos-android/
[6] https://www.androidpolice.com/google-not-good-os-ui-chromeos-to-android-editorial/
[7] https://support.google.com/chromebook/thread/310058731/is-google-replacing-chromeos-with-android
[8] https://www.reddit.com/r/chromeos/comments/1guatqu/source_google_is_turning_chrome_os_into_android/

The Web as a Universal UI Layer

Okay, but the point still stands. The Web is a killer user interface layer. Both ChromeOS and the Electron platform demonstrate this. Oh, another platform, WebOS from Palm sort of demonstrated it, though this also died… sort of. Hmmm, a lot of things that take up the Web as its main UI seems to die. Maybe I should do some rethinking, haha!

Pipulate’s Approach to Web UI

No, Pipulate doesn’t turn it into something else. Pipulate keeps using the Web browser as a web browser. It doesn’t try to swap out the underlying browser with some new platform. It just serves locally! Anyway, for those curious about WebOS… Perplexity?

Perplexity: Palm’s WebOS was an innovative mobile operating system developed by Palm, Inc. and released on January 8, 2009[1][5]. It was designed for smartphones, internet tablets, and smart home appliances, based on the Linux kernel[1]. WebOS pioneered several features that are now common in modern mobile operating systems:

1. Multiple synchronized calendars
2. Unified social media and contact management
3. Curved displays
4. Wireless charging
5. Integrated text and Web messaging
6. Unintrusive notifications[5]

One of WebOS’s unique aspects was its use of native internet technologies like JavaScript for local applications, which allowed for extensive integration with web services[5]. This made it stand out from its competitors at the time.

Key events in WebOS history:

• June 2009: Palm Pre, the first WebOS device, was released[7]
• April 2010: HP acquired Palm for $1.2 billion[9]
• February 2011: HP announced plans to use WebOS as a universal platform for all its devices[9]
• July 2011: HP released the TouchPad tablet running WebOS 3.0[9]

Despite its innovations, WebOS faced challenges in the competitive mobile market. HP’s acquisition of Palm in 2010 was intended to leverage WebOS for various products, including smartphones, tablets, and printers[9]. However, HP’s plans for WebOS were short-lived, and the platform ultimately failed to gain significant market share.

Today, WebOS lives on in a different form. LG acquired WebOS in February 2013, and it is currently the main operating system for most LG TVs produced since 2015[1].

Citations:

[1] https://betawiki.net/wiki/Palm_Web_OS_(HP_Web_OS)
[2] https://www.daewooindia.in/blog/webos-vs-android-tv/
[3] https://en.wikipedia.org/wiki/Palm_OS
[4] https://www.enveu.com/blog/webos-vs-android-tv
[5] https://www.salon.com/2017/09/03/remember-palms-webos-maybe-not-but-apple-and-google-definitely-do/
[6] https://www.reddit.com/r/Palm/comments/16cgob9/i_ported_a_legacy_palmhp_webos_app_to_modern/
[7] https://lowendmac.com/2016/a-history-of-palm-part-5-the-end-and-the-post-mortem/
[8] https://starshine.co.in/blogs/blog/webos-tv-vs-android-tv-a-comprehensive-comparison
[9] https://en.wikipedia.org/wiki/WebOS
[10] https://blog.dustinkirkland.com/2009/10/palm-pre-webos-vs-htc-g1-android.html
[11] https://displaydaily.com/the-long-and-winding-road-of-lgs-webos/

Right, okay so the Web provides a killer future-proof user interface layer. I think it’s even bigger than the two big contenders in the free and open source software world, TK and QT. The histories of each? Perplexity, give me a history of TK in the sense of Tcl/Tk and KDE/Qt.

Perplexity: While the Web has indeed become a dominant platform for user interfaces, both Tk and Qt have played significant roles in the history of graphical user interfaces for desktop applications. Let’s explore the histories of Tk (Tcl/Tk) and Qt (KDE/Qt):

Tk (Tcl/Tk)

Tk was created by John Ousterhout around 1988 while he was a computer science professor at UC Berkeley[5]. It was designed as an extension for the Tcl scripting language to easily build graphical user interfaces (GUIs)[1]. Key points in Tk’s history include:

• 1991: First public release of Tk[1][5]
• 1992: Adoption of Tk began to grow rapidly[5]
• 1997: John Ousterhout received the ACM Software System Award for Tcl/Tk[1]
• 2007: Tk 8.5 released, adding new widgets and modernizing the look and feel[1]

Tk pioneered several features that made it popular in the 1990s, including:

• Cross-platform support (initially for Unix/X11, later Windows and Macintosh)[1]
• Ease of use compared to other X11 toolkits of the time[1]
• Native look and feel introduced in version 8.0 (1997)[1]

Qt (KDE/Qt)

Qt was conceived in 1990 by Haavard Nord and Eirik Chambe-Eng in Trondheim, Norway[2]. It became the foundation for the KDE project, which was announced in 1996[4]. Key events in Qt and KDE history include:

• 1995: First public release of Qt 0.90 for X11/Linux[2]
• 1996: KDE project announced, using Qt as its underlying library[4][6]
• 1998: KDE 1.0 released, the first stable version of the desktop environment[6]
• 1998: KDE Free Qt Foundation established to ensure Qt’s availability for free software development[2]
• 2005: Qt 4.0 released, a major overhaul of the framework[2]
• 2008: Nokia acquires Trolltech (Qt’s creator)[2]
• 2011: Digia acquires Qt commercial licensing business[2]
• 2012: Digia acquires all rights to Qt[2]
• 2014: Qt Company becomes its own entity[2]
• 2024: KDE Frameworks 6 released, upgrading to a Qt 6 base[8]

Qt has evolved from a GUI toolkit to a comprehensive framework for developing cross-platform applications. It has been used in various projects beyond KDE, including the development of desktop, mobile, and embedded applications[2][6].

Both Tk and Qt have made significant contributions to the field of GUI development, with Qt gaining more widespread adoption in recent years due to its continuous development and broader feature set. However, Tk remains relevant, particularly in scientific and engineering applications where Tcl is commonly used[1][5].

Citations:

[1] https://en.wikipedia.org/wiki/Tk_(software)
[2] https://wiki.qt.io/Qt_History
[3] http://www.tcl-lang.org/about/history.html
[4] https://timeline.kde.org
[5] https://tkdocs.com/resources/backgrounder.html
[6] https://en.wikipedia.org/wiki/KDE
[7] https://en.wikipedia.org/wiki/Tkinter
[8] https://en.wikipedia.org/wiki/KDE_Frameworks

Defining Future-Proof Development for Part-Time Developers

So what I’m effectively doing is surveying the landscape and deciding what “future-proof” means for a low-level part-time developer like me. I’m never going to be a Fernando Corbató, Ken Thompson or Guido van Rossum (time-sharing, Unix and Python, respectively). Frankly, I won’t ever be like one of the people who made the lower-level tools accessible, like Jeremy Howard and Carson Gross who did some brilliant dot-connecting to make FastHTML possible. But I can recognize FastHTML for what it is… unprecedented, and the tool I’ve been waiting for.

Revisiting the Pipulate Vision

And that’s where it all goes full circle. This is basically a re-thinking-through and reaffirming of my Pipulate vision, which has thusfar been before it’s time. The pieces had not fallen into place. I am confirming in my mind now that they have, and plotting the path forward.

From Notebooks to Web Apps: The Next Evolution

Plotting the path forward simply means picking up where I left off a couple of blog posts ago, on DRY vs. WET and the logical next step in Pipulate, which unlocks its rapid porting potential from Jupyter Notebooks to Web Apps.

And now I have the AI assistance I need in the Jupyter Notebooks themselves, via Cursor which just fell into place.

Plink, plink, plink, the parts fall into place for Pipulate.

Seizing the Moment: The Sprint Begins

This is a sprint, not a marathon. I’ve got to move, move, move! The iron is hot, and regardless of how tired and demoralized I’ve gotten over the years, trying to implement something before its time, I cannot and must not let that slow me down or stop me today. I am in the perfect place. I have the perfect parts. Let’s get pipulating!

An AI’s Take

Ideas for Titles and Headlines:

• “Chip O’Theseus: The Evolving AI in a Bottle”
• “From Jupyter to Web: My Journey with AI and Pipulate”
• “The Timeless Tech Stack: Building the Future with Past Innovations”
• “AI Assistance and the Pipulate Vision: A Developer’s Breakthrough”
• “Decoding the Ship of Theseus: Memory, Databases, and Local LLMs”
• “The Web as UI: Bridging the Developer-User Divide”
• “Pipulate: A Personal Sprint to Web App Innovation”
• “Ken Thompson’s Legacy and My Quest for Future-Proof Development”

My Opinion of the Article:

This article is a compelling blend of personal development narrative and technical exploration. It effectively captures the author’s enthusiasm and determination while providing insightful perspectives on the evolution of technology. The author’s deep dive into the historical context of various tools and frameworks, coupled with their reflections on future-proofing and accessibility, makes for a thought-provoking read. The “Ship of Theseus” analogy is particularly apt, highlighting the dynamic nature of software development. The author’s candid discussion of their challenges and breakthroughs adds a relatable human element, making the complex technical details more engaging. Overall, the article is a well-crafted piece that balances technical depth with personal passion.