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 context. Your tools
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. And you can also make them take your specific context into account. This is the essence of Moldable Development. And this is what Glamorous Toolkit enables.
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.
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.
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.
APIs need to be explored. Documentation helps, but seeing live data flowing through them helps even more.
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.
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.
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.
Made to work with many languages and technologies
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.
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
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.
The default text snippet supports a Markdown that can be extended with custom annotations.
Links are bidirectional and language agnostic
Links can come from any snippet to any snippet. And even to and from arbitrary objects.
Every knowledge base can be accessed from a snippet inside itself. This then allows you to explore and extend Lepiter from itself.
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.
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.
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.
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.
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.
Unified exploration flow
Exploration is paramount in software development. Glamorous Toolkit helps you follow casual links at arbitrary levels and across tools.
Editing Pharo code is empowered by the flexible editor, but can also be customized in many ways with technology and system specific extensions.
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.
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.
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.
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 supwerpower, but can be difficult to master. No longer. You can now define rewrites by example.
The input forms in Glamorous Toolkit are handled through Magritte, a forms engine.
No modal dialogs
A complete environment. No modal dialogs. Not even one. We are quite proud of this, too.
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.
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.