dddappp: A Domain-Driven DAPP low-code development Platform


English 中文

Our Vision

Our goal is to create a true low-code development platform (LCDP) that allows developers to easily build highly complex decentralized applications (Dapps).

With our low-code development platform, we want to enable developers to take full advantage of the decentralized technology infrastructures without caring about the underlying technical details.

Our platform adapts to both current needs and future possibilities. Developers are not limited by any specific programming language or blockchain platform, they only need to focus on implementing the “business logic”. In this way, whether it is complex “traditional” enterprise software or Web2 internet applications, they can easily transform into decentralized Web3 applications.

What is a “true” low-code development platform

In fact, there is already a relatively unified evaluation standard for what is a low-code development platform in the industry.

If you think that “low-code” means “the less human-written code, the better, preferably no code at all”, or if you think that “the best low-code platform is a no-code platform”, then you are very wrong.

Here we need to clarify a common misconception, which is the confusion between “low-code” and “no-code”.

We believe (and it is also widely recognized in the industry) that a true low-code development platform should have the following key features:

We believe that such a “true” low-code development platform has not yet appeared in the decentralized world. We have the confidence and ability to create it.

Our Value

We firmly believe that low-code development platforms are the future trend of blockchain application development. They can enable developers to quickly and easily build high-quality Dapps without worrying about the underlying technical details. They can also attract more “traditional” application developers to enter the blockchain field, using their knowledge and experience accumulated in various industries and domains, to create more valuable and meaningful Dapps.

In the initial stage, our low-code development platform will support Dapp development based on various Move platforms.

Why we start with Move language

We love blockchain technology, especially the revolutionary innovation of “resource-oriented programming” in the Move language. We believe that the combinability of resources can greatly accelerate the innovation in the Move ecosystem, and thus foster some killer applications that are hard to achieve on other blockchains.

But we also realize that there are still many challenges and pain points in blockchain application development. Even with the Move language, developing a slightly complex Dapp still requires a lot of time and effort, as well as mastering different technology stacks and tools. That’s why we want to create a low-code development platform that makes Move application development simpler and more efficient.

Provide support for DAOs

We especially want to emphasize the huge imagination space that can be raised by the combination of low-code platforms and DAOs (decentralized autonomous organizations). DAOs are “legal persons” that exist in the blockchain world, which can achieve some efficiency and transparency that traditional organizations can hardly reach. Obviously, DAOs need more “business activities” to be on-chain, which requires more support from blockchain “business software”. Low-code development platforms can enable DAO creators and participants to easily build Dapps that meet their needs and visions, and also allow them to modify and optimize them at any time.

Traditional low-code development platforms have already proven their advantages in rapid development of traditional “enterprise applications”, and we believe this will be the case in the Web3 era.

Current State of Web3 Low-Code Development

If we measure the traditional low-code development platforms for enterprise applications in the Web2 era according to the above criteria for “true” low-code, we can see some relatively outstanding leaders, such as OutSystems, Mendix, Salesforce, etc.

Magic Quadrant for Traditional LCDPs

Then, in the Web3 era, are there any equally excellent Dapp low-code development platforms?

Unfortunately, according to the strict “true” low-code standards mentioned above, we have not yet seen the emergence of such a Dapp low-code development platform…

Why is it so hard? Why can’t they do it?

The “model-driven” of enterprise application low-code platforms

Traditional enterprise software development platforms (including low-code platforms) basically use ER (entity-relationship) models and/or relational models (the models used by SQL databases) to “drive” development.

For example, see how OutSystems does it?

"Model Driven" Of OutSystems

OutSystems uses both ER models and relational (data) models (some enterprise software development platforms only use one of them).

There is a fairly direct correspondence between the concepts used by the ER models and the relational models, so their modeling results (the generated codes) can easily run on the traditional enterprise software technology infrastructures - SQL databases. But they are difficult to run on new technology infrastructures such as blockchains - where the mainstream smart contract platforms and “decentralized ledgers” are constructed too far from traditional SQL databases.

Obviously, developing a “true” low-code platform requires long-term accumulation of technology and experience, and the technology routes used by traditional enterprise application low-code platforms make it difficult for them to be ported to the new field of Dapp development.

As for the existing Dapp “low-code” platforms, you might ask: “They don’t have those features, but what does it matter?”

The importance of core values

Developing a true low-code platform - especially adhering to “model-driven” - is undoubtedly a difficult path. In our view, the reason why existing Dapp “low-code” platforms are not very successful is because they always try to take shortcuts.

Never forget the original intention, the only way to get to the end.

We believe that the potential of a platform is determined by its “core”. The core features that a professional low-code platform should have, such as model-driven, expression language, have values that are difficult to replace by other solutions that try to “bypass” them.

For example, “configurable smart contract templates” certainly have their value, which is to improve the efficiency of developers copying, pasting, and modifying “ready-made codes” - provided that there are indeed “ready-made codes”. If developers want to make some innovative applications and there are no ready-made “smart contract templates” available, then they won’t be able to help developers; when they need to support “multi-chains”, it is also a big burden for platform developers to write and maintain such a library of “smart contract templates” in different languages (Solidity, Move, etc.) for different chains. “Smart contracts” are often only the on-chain part of an application, and decentralized applications often also require off-chain service development.

There is also the “expression language”, although it may be complex to implement this feature perfectly (even if our platform wants to implement it, the priority can be relatively low) - we need to develop compilers that compile the code written in this expression language into instructions that can be executed by the virtual machines (EVM, MoveVM, etc.) of each chain - but with it, developers can only use this “expression language” to write business logic, and the developed application can run directly on different chains. There is no need to learn and use each chain’s development language, which greatly saves the cost of application development and porting.

Our Technology

Our low-code development platform’s core feature is “model-driven development”. Of course, it is also the core feature that any “qualified” low-code development platform should have.

Domain models as the core

The key is the modeling paradigm!

Unlike traditional enterprise application low-code platforms that usually use relational models and/or ER models, our platform uses DDD (Domain-Driven Design) style domain models, which is the fundamental reason why our platform is so unique and powerful.

DDD domain models are a kind of OO (object-oriented) models with a relatively high level of abstraction, which can be easily mapped to lower-level models such as programming language object models, relational models, etc. On the other hand, mapping low-level models to each other is relatively difficult and often requires developers to intervene or even write a lot of implementation code.

Mappings Between Models

To build domain models, we need a domain modeling language. This language must meet the following requirements:

The question is, can we find such a language that meets the above requirements?

Fortunately, we have found it. More precisely, we invented it.

Domain-Driven Design Modeling Language (DDDML)

DDDML (Domain-Driven Design Modeling Language) is a DDD-native DSL that we invented. It allows you to describe your domain model in a concise, clear, and natural way.

Eric Evans, founder of Domain-Driven Design, has said that he has always believed that DSL is the next big step in the evolution of domain-driven design.

DDDML (Domain-Driven Design Modeling Language) takes this solid “big step” forward.

With DDDML-described domain models, we can build a toolchain that generates code for various parts of applications from models and then runs applications on various technical infrastructures.

Domain Models As the Core

Our Team

You have chosen a path that other Dapp low-code platforms dare not try… Although theoretically you are right, what makes you confident that you can do it?

Because, “using DDD-style domain models to drive development” is something we have done in the Web2 era!

E-R Model/Relational Model Driven Vs. Domain Model Driven

At that time, we were not satisfied with implementing a “traditional” low-code development platform. We wanted to use DDD-style domain models to drive the development of new types of enterprise applications (SaaS) and internet applications. This was a very bold and innovative attempt. But this path was feasible, and we had a lot of valuable experience accumulated. We even published a thick monograph to share our experience with developers.

Our project architect is Jiefeng Yang. He has more than 20 years of software development experience, DDD expert, DDDML creator, and author of the technical book “Deep into DDD: Driving Complex Software Development by DSL”.

It is in the book “Deep into DDD” that we elaborate on the design of DDDML, the native DSL for DDD, and its related development toolchain, and how to use them to solve various pain points in complex software development processes. The book was published in April 2021 and reprinted in September of the same year, receiving wide acclaim.

The Book "Deep into DDD"

That is to say, as early as in the Web2 era, we had completed the construction of the key technology theoretical system of this low-code platform and put it into practice successfully.

In addition, Jiefeng Yang is also one of the developers of, or has provided key technical support for, several important ecological foundation projects on Starcoin, the first Move public blockchain.

Developers all know that a dictionary / hash table is a data structure that is often used in application development (in Solidity a similar data structure is called mapping). When Move’s stdlib and Starcoin Framework didn’t have Table, we needed to use some methods to “bypass” this limitation when developing Starcoin applications. For example, we can use the off-chain SMT (Sparse Merkel Tree) + on-chain root hash solution. Such a solution can be quite tedious to implement programmatically, but using a low-code development approach, we can shield a large portion of the complexity (brought by limitations of the technology infrastructure) from app developers. See the exploration in this link.

Our Product

Our low-code development platform is called dddappp, which stands for Domain-Driven DAPP low-code Platform.

We have implemented MVPs (Minimum Viable Products) based on three well-known Move smart contract platforms: Sui, Aptos and Rooch.

🎉 This project is one of the first round grant recipients of the Sui Foundation (the first one listed): https://sui.io/resources-sui/sui-foundation-round-1-awardees/ 🎉

This means that you can now use our dddappp CLI tool to develop decentralized applications based on Sui, Aptos and Rooch!

Just follow the instructions in the links below, and you can experience the powerful benefits of “model-driven”!

Our Roadmap

This is a challenging and visionary project, and we will implement our vision in stages.

Phase I

We need to develop a basic command line tool or a set of tools that can help developers generate on-chain Move contracts (the on-chain part of a Dapp) and off-chain services (written in Java) from domain models.

We have successfully completed the work of Phase I.

Phase II

We will migrate the command line tools or toolset developed in Phase I to the cloud, and provide a simple and easy-to-use Cloud IDE for developers to write domain model code, generate and deploy Dapp applications with one click, and provide testing environment and debugging tools.


GitHub: https://github.com/dddappp

Email: yangjiefeng AT gmail.com