Holochain Forum

Follow-up on Low code zone : Designing and creating a full Holochain low code platform

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 !

7 Likes

Sounds awesome brother! :slight_smile: Myself and @walter.almeida have been talking a lot about Low Code Solutions for Holochain for sometime now, as you all may already be aware I have been working on the .NET HDK for just over a year now and it started of as a Low Code Generator, which worked in a similar way to GO, in that it used C# and Rust templates to dynamically generate C# and Rust code.

This was built on top of HoloNET (the .NET and Unity Client I built back in 2019), so the C# code it generated had HoloNET integrated into it, which called into the dynamically generated rust code. This was all working fine and was about to release last Sept when RSM was announced so I decided to hold of. Unfortunately, it has taken nearly a year to get RSM working on Windows, so this is what has delayed me releasing the .NET HDK.

But the good news is this gave me time to refactor and improve the .NET HDK and also integrate it with the OASIS API so it is now de-coupled from Holochain and can generate dynamic native code for any OASIS Provider (currently supports Holochain, EOSIO, Telos, SEEDS, Ethereum, IPFS, Neo4j, MongoDB and SQLLite). It then evolved into the STAR ODK (OASIS Development Kit).

This allows users to debug their Holochain apps in C#, something they cannot do in Rust. It splits out the BLL (Business Logic Layer) into C# and the DAL (Data Access Layer) into Rust. It also allows you to build and publish your hApp using HoloNET (has the Holochain Conductor built in) so the user never needs to worry about the conductor or even touch any rust if they did not want to. Of course, people can customise the C# and Rust code that is generated as well as edit the templates it is built from (CRUD).

Also, the generated hApps have the conductor integrated, which is automatically started and stopped by HoloNET (one of its many powerful features) so they do not need to worry about shipping and configuring the Conductor separately.

STAR ODK can do a lot more on top of this, soon I will also be adding the ability for it to compile into WASM (Web Assembly) as well as run Holochain in a browser fully integrated with client side WASM so it will be full stack WASM running in a browser! :slight_smile:

I have just got the Windows binary working after waiting patiently for 2 years so now that has unblocked me once again to release HoloNET RSM followed by STAR ODK/HDK hopefully not too far behind.

STAR ODK is modelled on the Omiverse itself so contains Multiverses, Universes, Galaxies, Stars, Planets, Moons, etc. The first OAPPs (OASIS Apps) created will be Moons orbiting the first planet (Our World) and this is the beginning of the OASIS Metaverse you see in Ready Player One… :wink:

Read more here:

You can for example have a Holochain Galaxy, EOSIO Galaxy, Ethereum Galaxy, etc where they all interoperate including cross-chain smart-contracts even within Holochain… this is the grand vision I have held for many years now and now it is all coming together… I hope to release STAR ODK within the new few months.

The OASIS API was released last Oct as a REST API:

http://api.oasisplatform.world

So, it can already be used to build OAPP’s with for devs. STAR ODK will open the doors for non-coders to also build OAPPs as well as bridge Holochain to every other network and the massive unity, c# and enterprise sectors. STAR can generate apps, websites, games, services, basically anything that has the templates created for.

We have just taken on 8 web devs to help finish the UI to the OASIS API here:

http://oasisplatform.world

We have also just taken on 3 devs to help finish the Our World AR Geo-location prototype built on Holochain and the OASIS API. We also have taken on 3 C# devs to build out more of the OASIS Providers including ThreeFold, ActivityPub, COSMOS, Ultra, Solana and others… so lots happening, and things finally are speeding up now, yay! :blush:

My mission is to integrate everything to everything to remove all silos once and for all, it is unity consciousness expressed within the technical sphere…

One of the main goals of the OASIS API is to help create bridges to Holochain from everything else allowing quicker and easier migration paths to Holochain… Also, once you have built your OAPP you never need to worry about upgrading to the latest version of Holochain or porting to yet another tech stack where you need to keep learning new languages, tools, etc. The OASIS will handle all this for you by continuously adding OASIS Providers to connect to everything else.

It also had auto-fail over so if one node on one network goes down it will automatically switch to the next fastest node in your area regardless of what network or platform it is running on. It also has auto-load balancing so you will always get the fastest speed possible utilising the power of ALL the networks (eventually the entire internet). It also has auto-replication, so your data is auto-replicated across networks for maximum fault tolerance. You also have full control of your data as well as owning your data so you control what is shared and where.

Finally, it gives a SSO across all the networks using the Avatar/Karma system so you no longer need to remember countless passwords, etc.

Read more here:

The Power Of The OASIS API

As you can see this has some overlap with GO, which is why I am keen to integrate GO with STAR ODK, can you imagine how powerful both would become then?! :slight_smile: GO has more work done on building the web app UI’s along with relevant workflows and business logic so this will save me time not having to build that part as I had originally planned… this will free me up to focus more on the interoperability parts, which is my area of speciality.

I also hope to integrate CRISPR and anything else that can enhance the platform. The whole is greater than the sum of the parts… :slight_smile:

The future is bright…

The future is Holochain… :slight_smile:

Much love & blessings,

D. :heart: :heart: :heart:

1 Like

@guillemcordoba any feedback on this proposal ? Is the low code exploration still in progress, and how do you feel about my offer to help ?

1 Like