Introduction To Virtuoso

Virtuoso is an application development workflow consisting of a framework and a content library of components. Virtuoso can be thought of as "after-market" No-Code which adds No-Code visual programming on top of existing programming workflows. 

No-Code and Low-Code platforms generally offer great power in terms of quickly building useful applications at a fraction of the cost. However, they have many painful limitations:

1. Vendor Lock-In: When you pick a No-Code platform to build products or tools for your business, you are locked in to that platform. Migrating to a different platform is either extremely difficult or impossible.
2. Lack of Flexible: When you use a traditional No-Code or Low-Code platform, you are cut off from underlying build systems and native third generation languages (3GLs such as Java, C#, etc.) which are the source of power and flexibility.
3. Lack of openness: While some No-Code and Low-Code platforms have basic plugin extensibility at best, developers have very limited ability to create content using normal Pro Code skillsets and programming experience they already possess.

Virtuoso solves all of these problems, combining the power that No-Code and Low-Code has to offer, with none of their drawbacks to the user. The end result is a native project, fully formed, with the underlying Pro Code 3GL environment and build systems completely intact. Indeed, you could build an application with Virtuoso and then completely uninstall it. Your project would still build and run like normal, as if developed from scratch using the conventional build system.

In addition to providing higher levels of abstraction, Virtuoso is focused on collaboration and composability, and includes wizards to allow developers to create No-Code components from their third-generation language (3GL) libraries. Many software solutions, such as AI, involve useful components that are only smaller parts of a larger problem that a user is trying to solve. These components or mini-solutions will continue to grow in sophistication and require more specialized knowledge, easier integration, and a digital economy. Virtuoso provides this composable software architecture, digital economy, and No Code composition of software solutions. And best of all, it's Core Framework (more on that later) and No-Code platforms are free.

So why would you actually pay money to use an inherently less powerful, flexible, and scalable technology? 

The Core Framework is designed to accommodate the graphical development of an application, called the “host application”. After the application is designed graphically in the schematic editor, the design gets pushed to the host project, which is written in the language specific to that host, for example C#. Virtuoso handles creating and updating the host application according to the graphical design, essentially taking the graphical drawing and converting it to a corresponding application written in the host language.

Developers can develop their application entirely in the Virtuoso schematic, as may be the case if the developer does not know the underlying host language. Or the developer can just use the schematic as a starting point for an application design, using the convenience of the graphical design and graphical library, and then extend the design with additional custom functionality written in the host language. Subsequent changes to the schematic design can be made and pushed to the host application without affecting the host code you have added yourself.

The figure below shows this general workflow. Virtuoso is used to create a host. Components are graphically added to the schematic editor and configured, with ports connected as necessary. The Core Framework then emits the host code into the project needed to implement the schematic, using the optimum design pattern specific to the host language. For example, for a WPF C#/.NET host, the schematic editor will produce a design implemented with a Model-View-View Model design pattern as a starting point, and the developer can from there add and extend the functionality of the host directly in C# and XAML.

This workflow is ideal for applications that can be naturally expressed declaratively as a set of components logically interacting with other components in some way. The components may only represent code execution of business logic, or the components may represent controls which the user interacts with on the application view. In the Virtuoso host design paradigm, there is thus a schematic layer to the design and a visual layer. Each schematic component may or may not have a corresponding visual control on the view for user interaction. The logical component is represented as a model or view model, and the visual component is represented as a view bound to the corresponding view model. For a component that has a visual element, there is always a one-to-one correspondence between the component’s view on the visual layer and the component’s view model on the schematic layer.

In the example below, the schematic on the left shows a push button component and an LED component. The components have a boolean output port and a boolean input port, respectively. The ports are connected, representing that when the push button is pressed (true), the LED should be on. The view on the right shows the corresponding user interface. After placing the components on the schematic editor, making the connection between the ports, and pushing the updates to the host, the user simply needs to position the push button and LED view components, build the project, and run.

The Virtuoso Core Framework is built to be completely extensible to new host languages, new port types, and new components. You can easily write so-called “port metadata” classes which define new port types and defines the code to be emitted to represent a logical connection between that port type and any other port type, for a given host language. You can then write new components to use those port types, and then use Virtuoso to quickly create applications specific to your application domain using a schematic design flow.

The Virtuoso Core Framework is free for development purposes, as described in the Core Framework End User License Agreement. You may also deploy applications built using the Core Framework for commercial purposes, in some cases free and in other cases subject to a 5% royalty on gross revenue, also as described in the Core Framework EULA.

To summarize, the Core Framework is designed for both power and flexibility. It allows applications to be developed graphically without requiring knowledge of the host language, using an ever-expanding content library of components. Its extensible architecture allows you to customize and extend the functionality and components of Virtuoso to enhance existing ecosystems or forge new ones. It also allows any host application designed initially in the schematic with Virtuoso components to be further developed by host language developers using the same application paradigm they are used to. Virtuoso components emitted to the host appear just like any normal class instance and can be interacted with in the same way.