Skip to main content

Breakthrough in Software Development: From Programming to Orchestration

· 4 min read

Over the past decades, development tools have continuously evolved in programming capabilities, yet orchestration abilities remain absent. Business systems comprise modules like portals, pages, components, models, and services—their organizational relationships determine architecture quality. Traditional tools lack visual orchestration support, hiding system structures within code and making maintenance difficult. Software development is undergoing a shift from programming-centric to balanced programming and orchestration, where orchestration-oriented architectures, frameworks, and tools deliver both improved development efficiency and sustained architectural elegance.

The Essential Relationship Between Programming and Orchestration​

Every system consists of structure and process. Programming produces functions; embedding functions into objects creates new structures—this is orchestration. Orchestration produces objects; using objects within functions implements business workflows—this is programming. They complement and transform into each other.

Programming excels at expressing procedural logic, describing how systems operate; orchestration excels at expressing structural relationships, describing how systems organize. Over decades, development tools and frameworks have advanced in programming capabilities, but orchestration abilities remain absent. Managing business system structures still depends on individual developer expertise rather than systematic support from tools and frameworks.

Structural Deficiencies in Traditional Development Paradigms​

Current development tools universally lack module orchestration capabilities. How to design system architecture, organize modules, and clarify relationships depends entirely on developer experience. Tools provide no visual orchestration capabilities, and frameworks don't support visual module management.

Some low-code platforms attempt to solve this through DSL, but DSL's expressive power is limited by designers' foresight, falling short when facing complex and evolving enterprise requirements. The closed nature of DSL engines severely restricts technology integration capabilities, unable to keep pace with modern technology ecosystem evolution. Today, with npm hosting millions of packages and GitHub accumulating vast open-source repositories, users expecting to adopt new technologies must wait for platform vendors to provide adapters.

Visualization is Fundamentally About Structural Expression​

The true value of visual development lies in orchestration, not programming. It materializes abstract system structures, enabling developers to intuitively see system modules and their relationships, organizing and configuring them visually. This requires open orchestration protocols rather than closed DSL engines, unlimited extensibility rather than constrained expressiveness.

This demands a fundamental shift in technical approach: building systems on open architectural protocols where each module is self-describing, perceivable, and drivable; supporting developers to freely extend and integrate various technology implementations rather than being constrained by vendor lock-in. Only then can visual development support the complex requirements of enterprise applications.

Orchestration-Oriented System Architecture​

JitAi builds orchestration-oriented system architecture based on the open JAAP protocol. It defines system modules through a Meta/Type/Instance layered structure: Meta defines module categories, Type encapsulates technical implementations, and Instance carries business configurations. This design supports developers in infinitely extending existing modules and integrating new technology implementations. The architecture's openness manifests in every module being self-describing, supporting dynamic loading and hot-swapping, with no static dependencies between modules—functioning as independent resource packages freely reusable across applications. JitAi's visual tools preserve programming capabilities while supporting orchestration, enabling developers to assemble modules visually, preview effects in real-time, and continue manually editing the automatically generated code.

At the business system level, enterprise applications comprise elements like portals, pages, components, models, services, approvals, events, tasks, permissions, organizational structures, authentication methods, and databases. JitAi's development framework encapsulates these elements into different element families, providing numerous out-of-the-box Type elements. Developers simply create Instances and orchestrate them visually to assemble complete systems. This visual orchestration delivers two core values: first, significantly improved development efficiency—system structures and module relationships become clearly visible, eliminating repetitive searches through code for dependencies; second, sustained architectural elegance—structural issues surface directly in the visual interface, prompting developers to optimize proactively. In traditional development, architectural decay often stems from structural invisibility—by the time problems are discovered, remediation becomes difficult.

From programming to orchestration represents a deepening understanding of systems. Programming and orchestration aren't opposing choices but complementary dimensions. Orchestration-oriented system architecture, development frameworks, visual tools, and application code represent the evolutionary direction of software development technology and the inevitable choice for enterprise-level complex application development.