Mold your development experience
Glamorous Toolkit is the Moldable Development environment. It empowers you to make systems explainable through experiences tailored for each problem.
Your own development experience
Programming, exploring data, browsing APIs, knowledge management, log investigations, domain modeling are all part of the same continuum. They require dedicated tools, but those tools can come to you in an integrated experience that is specific to your context. This is the essence of Moldable Development. And this is what Glamorous Toolkit makes practical.
A single environment. Many applications
Glamorous Toolkit offers a uniform environment made out of visual and interactive operators that can be combined inexpensively in many ways. Here are some examples.
Domain discovery
Discovering the proper model for a domain is difficult. You want feedback. Get it faster by exploring scenarios through executable examples. View the results through custom views.
Explaining a domain object through examples and custom views.
Software assessment
Code reading is the single most expensive development activity. Much of reading is actually about finding interesting places. Finding the root cause, finding where to add a new feature. Those are search activities. Or visualization ones.
An interactive exploration of dependencies between ActiveRecords in a Rails application that also shows the Ruby and SQL sources.
API exploration
APIs need to be explored. Documentation helps, but seeing live data flowing through them helps even more.
Exploring a REST API through custom views.
Data exploration
Data holds valuable patterns that can only be unearthed when they are made visible. Visualization is important but it becomes a superpower only when you combine it with modeling and exploration.
Exploring the data exported from a Twitter account.
System documentation
Documentation is only useful when it's accurate. Make the system tell its stories. Then assemble them into larger interactive narratives in a linked knowledge base.
Exploring the book about Glamorous Toolkit written in Glamorous Toolkit.
System specific editors
Editing a system becomes effective when the environment understands the system's context. Editors can go well beyond syntax and offer custom services right in the editing experience.
Editing a AT Protocol lexicon definition at the domain level: highlighting of name strings, completion inside JSON strings, navigation from a reference to its definition.
Join the conversation
Moldable Development has many implications both technically and business-wise.
Figuring systems out is expensive and pervasive. Not doing it well ends up creating black boxes that pile up on top of each other. As the world we build is based on software, we must make those black boxes explainable. It's a large problem that can only change if we deal with it explicitly. We need a conversation.
We created Glamorous Toolkit to have a concrete conversation about how we figure systems out. Join us.
What people say
A most fascinating environment.
GT is a point of light in the darkness. I have my reservations of course, but it is by far the best example I've seen of a live literate programming environment.
The first software system that I can seriously imagine to replace Emacs for me. Given that I practically live in Emacs, that’s not a small statement.
It is no exaggeration to say that #GToolkit is a work of genius built on top of a work of genius.
Build your own development experience
Every system is unique and deserves a dedicated environment. Scratch that. Every problem about any piece of a system is unique.
Yes, we know it's sounds crazy expensive. But it's really not. Glamorous Toolkit is programmable exactly so that you can create your own experience for each development problem inexpensively.
Wardley Map describing the benefits of custom tools that produce dedicated views that accelerate decision making.
Made to work with many languages and technologies
Glamorous Toolkit is implemented in Pharo, but it was designed to be extended for other technologies and languages, like GraphQL, Python or JavaScript.
Editing GraphQL and exploring a server response from a Lepiter page.
A dedicated environment for defining support for other languages.
Manage your knowledge base. Programmatically
Whether it's your personal knowledge base, or the documentation for your system, you want it linked and tailored to the context. Customize it with dedicated annotations and snippets created right in the environment.
And once you have a knowledge base, exploit by querying and visualizing it programmatically.
A custom visualization of pages and their interconnections from the Glamorous Toolkit book. The node in blue is the "Get started" page. The nodes in red are all the pages reachable from the "Get started" page.
Moldable knowledge management + multi-language notebooks
Glamorous Toolkit is powered by the Lepiter knowledge base engine. Lepiter is made out of snippets grouped into pages and can be used for various use cases. And like every part of the environment, Lepiter is also moldable.
Snippets define their own language
Each snippet defines its own language. Languages can be textual, like GraphQL or JavaScript. They can be visual, like a Wardley Map. Or even widgets.
An example with a preview embedded in a Lepiter page. The example is defined and viewed in a dedicated snippet.
Snippets interoperate across languages
Every page defines a shared scope for variables. Combined with an extensible proxy model, variables can be defined and reused across languages.
A page with a JavaScript snippet that is combined with a Pharo snippet to produce a visualization of dependencies defined in a Yarn file.
Extensible Markdown
The default text snippet supports a Markdown that can be extended with custom annotations.
A completion inside a custom todo annotation. The completion shows a date dialog for the due date.
Links are bidirectional and language agnostic
Links can come from any snippet to any snippet. And even to and from arbitrary objects.
On the left, we see a page with a Wardley Map in which one of the nodes has a link to another page. On the right, the linked page shows the Wardley Map as one of the references.
Queryable
Every knowledge base can be accessed from a snippet inside itself. This then allows you to explore and extend Lepiter from itself.
Visualizing the current knowledge base through a Pharo snippet. Clicking on nodes opens the page to the right.
Edit and view in a seamless interface
Editing and viewing happen in the same interface. We achieve this by making the editing capabilities appear in place.
A page containing text with two links and an example snippet. The second link ("Examples") appears expanded because the cursor is next to it. At the bottom, the example snippet shows the parameters when the mouse hovers.
Take your first steps in Moldable Development
Starting is easy. Download Glamorous Toolkit. Execute. That's it.
When you start, first focus on learning how to learn. Then pick a concrete problem you care about. Perhaps like the use cases above. Moldable Development takes a bit of time to get used to, but once you do, you won't want to go ahead without it.
Flexible graphical stack
All visual scenes are rendered using a single underlying tree, including the editor and visualizations. This allows us to create flexible, unforeseen experiences.
Inspecting the rendering tree and asking for the implementation of a shortcut available in a text snippet.
Extensible editor
The editor is made out of the same elements as every other visual widget in the interface. Because of this you can add adornments anywhere in the text. Combined with stylers, you can produce surprisingly elaborate editing experiences.
An editor on the definition of the Glamorous Toolkit baseline. The editor understands the meaning of the string because of the baseline specification interface and offers an expander adornment accordingly.
Built-in visualization engine
Visualizations are also made out of elements and are arranged through layouts modelled like any other layouts. The consequence is that visualizations are not confined to isolated panes. You can combine widgets with visualizations arbitrarily.
A visualization inside an inspector. The visualization shows editors of examples and their dependencies. The lines connect the editors with the other editors, and when the code reference is visible, with the element inside the editor.
What would you do if your tools had no walls?
Rigid tools make you split your problem along their boundaries. Glamorous Toolkit turns the problem upside down. Instead of relying on single purpose tools, you get an environment made out of interactive and visual operators with which to construct an integrated experience customized for your needs.
Reimagined Pharo development experience
Of course, Glamorous Toolkit does offer an extensive environment for Pharo development. It reuses the Pharo language implementation and core libraries, but it comes with a whole new environment that enables a new way of programming. Yes, new even for the Smalltalk world.
Live development in snippets and inspectors
Traditionally, Smalltalk development happened in the code browser and in the debugger. In Glamorous Toolkit you get to work in snippets and inspectors.
Creating a class directly while programming in a Pharo snippet.
Changing the class of an object in a full fledged coder embedded in the inspector. Executing code is also possible because self has a concrete value.
Unified exploration flow
Exploration is paramount in software development. Glamorous Toolkit helps you follow casual links at arbitrary levels and across tools.
A Lepiter page containing a visualization of a class hierarchy. Clicking on a node in the visualization opens a Coder on that classes.
Enhanced coders
Editing Pharo code is empowered by the flexible editor, but can also be customized in many ways with technology and system specific extensions.
Expanding PetitParser productions: this time, the expansion is framework specific and happens for a variable that is resolved to the corresponding method.
A class coder on the baseline definition of Glamorous Toolkit showing a map of the dependencies between projects. Selecting one project spawns a coder to the right.
Composable tools
The goal of Glamorous Toolkit is to empower you to mold your own development experiences. So, tools are not monolithic. Instead, they are made of reusable and composable operators.
A search in the global Spotter.
A Spotter in an inspector showing custom searches defined in the inspected object (and addressbook, in our case).
Example-driven development
The entire environment is tested and documented based on examples. Examples are like tests that return objects. This small change has interesting consequences.
Examples form graphs: you can build on top of other examples by using their returned objects. Examples are documentation, too: by combining the returned objects with custom views and a flexible knowledge base, you get the pieces out of which to build larger executable narratives.
A graph of examples. Executing an example shows the inspector to the right. In this case, the resulting object is a text editor showing an adornment for tracking cursor indexes.
The same example embedded both as code and as a result in a page that is part of the Glamorous Toolkit book.
Filters as first class citizens
Searching source code has always been a Smalltalk thing. Now, it's even more pervasive and composable.
References and implementers are just filters over code that, once inspected, show the code matches in live editors. Filters can be composed programmatically, too. When combined with inspectors, you get pervasive search opportunities.
Searching for references to a message in the current hierarchy.
An example of a composite filter combining searches for pragmas, references and abstract syntax tree matches.
Enhanced refactoring and rewrite support
Automatic refactorings were first implemented in Smalltalk. The engine remains the same, but the experience became more ... glamorous.
You can perform complicated refactorings directly in the editor. Furthermore, automatic code rewriting is a superpower, but can be difficult to master. No longer. You can now define rewrites by example.
An example of a refactoring editable inline.
A snippet defining a custom rewrite with the preview of code changes.
Extensible forms
The input forms in Glamorous Toolkit are handled through Magritte, a forms engine.
Adding a class through a form. Different fields offers different completion and validation.
No modal dialogs
A complete environment. No modal dialogs. Not even one. We are quite proud of this, too.
Closing the last window prompts for saving without a fully modal dialog.
Removing a method with references opens a dropdown to inform about those references, including allowing for the option of seeing the references to the right.
Rust enabled runtime
The Glamorous Toolkit virtual machine is formed by a Rust runtime that wraps and runs the Pharo virtual machine as a library in a separate operating system thread. The runtime also comes with Rust plugins and with an infrastructure for creating Rust plugins.
Inspecting a Pharo object that wraps a Rust object. The second and third panes show Rust objects in a seamless navigatio.
Distributed asynchronous images
Glamorous Toolkit comes with a asynchronous mechanism to work with multiple remote images. The remote images pull from a queue of tasks and can communicate back through a second asynchronous communication channel.
So, what exactly is Moldable Development again?
Please, take another look through this page. What do you see?
You see many shapes. The premise of Moldable Development is that there is no single perspective on a system that is correct. There are always many, and different parts of the system are best shown differently. These shapes summarize the system from specific perspectives. This then leads to a compressed communication and a new feedback loop.
Moldable Development is a way of programming through custom tools built for each problem. It's a systematic approach that can be employed at any level of abstraction.
Glamorous Toolkit itself is an extensive case study of how custom tools enhance programming abilities. It comes out of the box with thousands of extensions and examples that touch on the whole system.
The goal? To make the inside of systems explainable.
The need for moldability is pervasive. The treemap shows the classes of Glamorous Toolkit organized in packages. Blue denotes classes that contain at least one custom view; green shows those that have an example.