Hands-on Demo of Glamorous Toolkit & Moldable Development • Tudor Girba & Kris Jenkins • GOTO 2024
Tudor Girba introduces "Moldable Development," a paradigm where developers create thousands of custom tools to analyze and interact with their specific software context. He demonstrates this live using Glamorous Toolkit, transforming an unstructured text file into a browsable system with custom views, all within minutes.
The Philosophy of Moldable Development
Tudor Girba presents the concept of Moldable Development, an approach centered on the idea that our entire experience of a software system is mediated through tools. Consequently, the characteristics of these tools fundamentally shape our thinking and interaction with the code. The core problem in software development is its highly contextual nature; we can’t predict the specific problems a developer will face, so off-the-shelf tools are inherently inadequate.
A key observation is that developers spend the majority of their time—over 50%—reading and understanding code, yet the process of “how” they read code is rarely discussed or optimized. Moldable Development proposes to change this by transforming the time spent on manual inspection and gut-feel analysis into a creative process of building custom tools.
“Code anything in a system is data, it’s not text. It’s not a book. That’s the worst sidetrack this industry probably has ever taken over the last couple of decades. It’s data, and data doesn’t have a shape.”
The goal is to move from manual information synthesis to automated, generated views. This makes creating a new perspective on the system a commodity, allowing developers to generate a billion views at virtually zero cost. This process has a compounding effect: as more custom tools and views are built for different parts of the system, developers can ask increasingly sophisticated questions about the system as a whole, fundamentally changing the nature of programming.
The Challenge: Live Demo with Glamorous Toolkit
To make this abstract idea concrete, Kris Jenkins challenges Tudor to a live coding session. Tudor is given a text file with Dungeons & Dragons spell data that he has never seen before and is tasked with using Glamorous Toolkit to explore this new domain and build useful tools for it on the fly.
The demonstration showcases the following principles in action:
1. Interactive Exploration and Parsing
Starting in a notebook-like environment, Tudor inspects the raw file. He emphasizes that every object, even a simple string, can have multiple views (e.g., raw text, ASCII values, a list of characters). This is the smallest, most fundamental pattern of Moldable Development.
He then tackles the unstructured text by:
- Starting Small: Isolating a single spell entry to understand its structure.
- Building an Interactive Parser: Instead of using regular expressions, he interactively constructs a parser using a small, composable DSL. This parser is itself an object that can be inspected and debugged.
- Live Debugging: When the parser fails, the toolkit provides an execution trace, allowing him to immediately see where the logic broke and why. He debugs the parser’s logic live, adjusting it to handle the specific format of the input, such as variations in line endings or field names.
2. Elevating Data to Objects
Once the parser can successfully dissect a single entry into tokens, the next step is to raise the level of abstraction.
- He defines a new class,
MySpell, on the fly. - The parser is modified to output an instance of
MySpell, populating it with the structured data extracted from the text. - This transforms the raw data into a meaningful domain object that can have its own behavior and custom views.
3. Creating Custom, Contextual Views
With a MySpell object, Tudor demonstrates how to move beyond generic inspectors.
- He creates a new “raw data” view directly on the
MySpellobject, which shows the original parsed tokens. This allows him to see both the high-level object and the low-level data it came from in the same context. - He then begins building a rich-text view to format the spell’s information in a clean, readable way, demonstrating how quickly a custom visualization can be created.
The core thesis is that this process—inspecting, parsing, structuring, and visualizing—should be a rapid, iterative loop. By making tool creation cheap and easy, developers are empowered to constantly build new “lenses” through which to see their system, tailored to the specific question they are trying to answer at that moment. The demo, despite hitting real-world parsing challenges, effectively shows that building dozens or even thousands of such small, specific tools per project is not only feasible but a dramatically more effective way to develop software.