Hello everyone !
@guillemcordoba , @belindanoakes , @lucas.tauil , I am so excited to share here around the low code exploration. I took the opportunity of a road trip to watch all the low code zone videos : Low Code Zone - YouTube
I am amazed and so thrilled by your work and your exploration ! I want to offer my support and my open-source technology to go deeper in bringing low code to Holochain.
I want to emphasize that I am a big fan of Holochain for we share the same values and intention of bringing technology to create a new way to organize and interact with each other that is decentralized and sovereign.
I have already introduced myself and started a discussion around low code here:Low code development for Holochain Apps
My value for the low code zone exploration has 2 folds:
- Low code expertise, for having worked with low code technologies for 15 years and having developed the Generative Objects low code platform over the last 13 years
- Bringing the “Meta low code” platform Generative Objects to you guys, and supporting you for building you own unique Holochain low code platform (more on this later, especially on what means the “meta” part added to low code).
About Generative Objects (GO): it is an open source technology I have started implementing back in 2009 and has been used for many enterprise level applications. The big value it can bring to Holochain is that it is implementing for the first time ever (at least, I never saw that anywhere) what I call the “Meta low code” approach, that goes much beyond traditional low code.
For what I saw in the low code zone videos, you are crafting your own low code platform, in a “module and compose” way, composing and configuring at UI level, modules that are created by developers, and integrating GrapeJS for composite UI design (designing the pages receiving the modules).
What I would love to see, and where I can offer my help, is to actually go a step beyond, and have a way to also create the modules themselves through low code, and allow non-tech people to actually build full fledge, full specific modules and composite applications without coding. This is the full low code promise. Composing modules is good, but is the old way : modules stay specifics to solving a problem, and anyone using the modules are limited to using the modules the way they are, apart maybe for a few configurable parts. And that’s ok for very generic bits, like calendar and events. But real life challenges and collaboration goes much beyond, and we want to give full power to everyone to author any kind of application exactly how they want them. And innovation comes from doing things different! Re-using modules is a limitation to creativity and innovation, the idea is to unleash full power of all these beautiful conscious people who are everyone waiting for creating a better world !
And I get where the low code exploration went with composing modules : it makes perfect sense as building a full fledge low code platform as I describe above is a multi-years projects. Also, I understand that it was not relevant to use an existing low code platform to do it (except for very specific parts, like GrapeJS for the UI). Because until today, existing low code platforms come with the limitation of a predefined technological stack and architecture. And if you are lucky, you can actually see the code and the design of the stack, but most of the time it is a black box, or even a model interpreter (no code generation). It that sense, existing low code platforms are very limited : they are flexible (to certain extend) at functional level, but not at technical level.
Also, low code platforms empower people to build applications with a minimum or no technical knowledge. However, the applications that can be built are limited to the kind of applications a given low code platform was designed for, mainly data driven web applications. And the generated applications are limited to follow the built-in architecture and design.
Generative Objects goes much beyond, by proposing a new approach that I call “Meta low code”, rocketing the versality and power of the original low code approach to a whole new level.
The meta low code approach empowers developers to have full control over the application meta-model and the architecture and design of the generated applications. The application meta-model is the high level, functional language that the low code platform is exposing to non-technical users to create application in a low code way.
Developers can now :
- Enrich and extend the original Generative Objects meta-model and associated generation templates, to extend the low code platform itself to meet their specific needs.
- Create full new application meta-models, and associated generation templates. Developers can now literally create full-fledged specific low code platforms, to target any kind of application, design and architecture
Non-tech users can then use the specific low code platform, created by the developers.
By the way, I have in mind this meta low code approach from the beginning and designed Generative Objects from scratch with this in perspective : Generative Objects is self-reflective, this means that we use Generative Objects to build Generative Objects, which was further exposed by fully bringing the meta low code approach to developers by enabling the creation of new specific low code platforms using Generative Objects.
What it means for the low code exploration and Holochain: we can use Generative Objects to create a new low code platform specific to Holochain apps. And then use this Holochain low code platform to design and generated Holochain modules and applications !
A Generative Object low code platform is composed of two parts:
- A Functional meta-model. The meta-model is the non-tech, functional language used to define and describe target applications. This model is de-coupled from the technical target infrastructure
- A pipeline of generation templates, and other tasks, used to transform the meta-model instance to a working application, on a given technical architecture.
Which means that you can have more than one generation pipeline, targeting different technical targets, and evolve your target technical architecture independently from your applications models.
I believe that at least 80% of the existing Generative Objects functional meta-model will fit the needs for the Holochain low code platform. Because the functional needs are not dependent on the technical infrastructure, it is about creating applications for collaborating and communicating. What might change are things like the functional security model, and the definition of membranes because the agent-centric approach differs quite a lot from a perspective of who can access data, from a data-centric approach. It seems also that the notion of DNA could benefit from also a functional model, specific to that part.
So, the steps that could be taken as part of the low code exploration:
- We could progress immediately with Belinda to model the pilot applications, using the existing GO meta-model. That way, we can ensure we can express the functional needs without waiting.
- From this functional model, we can immediately generate a working web application, allowing to test and use the generated application, and iterate with the functional design process.
- In parallel, we can start writing the generation templates to target the Holochain infrastructure. A lot can be inspired from the existing generation templates, even though they target a data centric approach, because it implements many patterns around graph of objects, chained security rules, business rules and more.
- Once ready, we can regenerate the full application, targeting Holochain, without having to change the functional model (or just for specific parts like data access rules)
One word about composition, and composition at module/code level versus composition at model level
The classical approach of composition is composing existing modules. Modules are commonly binaries, code and UI elements.
The approach proposed by GO is to compose at functional level. That way, an end user can open the meta-model of an existing module, reuse it as is, or … extend it for specific needs. On the other end, composing at module/ code level implies that the module is already full and complete, potentially configurable, but in very limited ways. By composing at meta-model level, we open the power to reuse a module and yet completely adapt it to fit specific needs, and therefore it allows for a much higher level of versality.
Meta-model instances are then stored in GIT, which makes it easy to manage versions, branch meta-models, fork models, review meta-model changes, merge meta-model version etc.
The benefit of having functional meta-models, decoupled from the technical infrastructure, is paramount : Let’s imagine that Elemental chat, and all existing Holochain apps, were modeled on this new Holochain low code platform. These models would be de-coupled from the code. The way to translate the models to code would be through the code generation templates pipeline. The gain is here : whenever a new version of Holochain would be released, there is no need to touch the functional meta-model, but just the code generation templates, which is done once for all, allowing then to regenerate the whole stack of Holochain applications in the clap of a finger.
Also, a full fledge low code platform includes more than just code generation. GO includes a full generation pipeline that goes beyond just code generation, it can include any complementary tasks, like packaging, deploying, managing versions, testing and much more. In fact : whatever would be required to automate as much as possible.
My longer term intention is to co-create a decentralized “Wikipedia for applications”. In the sense that today, we are all empowered to co-author content, globally, using Wikipedia. What I envision is that tomorrow we will do that for applications and platforms. GO will be the meta low code technology to empower non-tech people, all of us, to co-design and co-create the decentralized platforms we need to create the world we want to live in and our new way to relate and organize ourselves as humanity, and empowering developers to bridge these needs of us people to specific technologies by leveraging the “meta” part of the GO platform. And I see as part of this, Holochain being the technology and infrastructure that will make this decentralized co-creation of our new world concretely possible. Since GO is self-reflected, once the generation templates targeting Holochain are ready, then …. We can re-generate GO to target Holochain and we will have a …. Fully decentralized Meta low code platform powered by Holochain, for creating any Holochain app, the Saint Graal !!! @artbrock , a lot has moved since we had a chat, I believe you will like that part !!
How about this ? Is it landing ? I could propose to participate to a next Low code zone episode to go deeper. It is a lot shared here, and there is even more to come, it would land in a much useful way by actually discussing with you guys and inspiring each other!
Looking forward to connecting with you guys !