Binding engine parts

In this segment, we’ll provide a concise overview of the components of a binding engine and outline their respective roles. While some components can be intricate and necessitate detailed explanations, we’ll initially offer a high-level perspective. More comprehensive examinations of each component will follow in subsequent sections.

Base classes

  • View base – a foundational class tailored for MVVM/MV* architectures, requiring a view model that is cognizant of binding.
  • Bindable element – a foundational component or widget designed for crafting standalone, binding context-sensitive, and reusable UI elements.
  • Observable – base class for enabling the observer pattern.
  • Perspective element – this enables you to seamlessly switch between views within a designated and confined area. An example of this would be tab sheets.
  • Context sharing widget – this doesn’t possess an independent context but rather shares one with another bindable context. It permits you to observe and engage with that context beyond the limitations set by the context element, whether it’s a view base or a bindable component.
    In “crs-binding” this would be the “crs-widget” component.

Event management

  • UI event listener – monitors the UI for any user interactions or alterations in input, such as clicking a button or editing the text of an input field. Certain input shifts will activate actions outlined in binding expressions or refresh the data within a binding context. The UI events should steer this process, grounded in user behaviors and the specified binding expressions.
  • Binding context change events – when adjusting properties on a binding context or objects along the path of such a context, it’s essential to determine if there are UI components requiring updates. If they do, we must execute the necessary update procedures.

These two event categories play a pivotal role in the execution of binding expressions, propelling modifications across the system.

Expression parsing

A significant aspect of binding engines revolves around articulating intent. This intent can manifest in various ways, including:

  1. Clicking a button should invoke a function on the binding context with specified parameters.
  2. If a property within the binding context alters, the corresponding input’s text should reflect that change.
  3. Modify UI styles based on a condition, where we assess a property or multiple properties within the binding context using a conditional expression.
  • Tokenizer – this tool segments the expression into distinct segments for ease of parsing. Employed by the sanitizer, it reshapes the expression into safe actionable code. The tokenizer aids in assessing the present token and its adjacent tokens, enabling a clearer comprehension of the expression’s context.
  • Sanitizer – this processes an expression to ensure its safety by confining it to a singular scope, provided a context argument is present. All properties are adjusted to reference this context argument, ensuring there’s no access to elements outside of what the executing function permits in terms of parameters.
  • Compiler – this component generates executable code by crafting a function intended to run the expression. To avoid redundancy, it caches these functions, ensuring that repeated expressions don’t lead to duplicated functions. The event system then employs the outcome of this process to implement the binding objective.


Managers are unique singleton classes used to register content that activates specific functions. They ensure a clear separation of duties for specialized binding actions. These managers oversee the resources affiliated with them and collaborate closely with the execution expression to achieve the desired result.

  • Inflation manager – consider a static template that represents a UI segment. Within this template, there’s binding expression markup that designates data placement, conditional styling, and interactions. When provided with a data set, an instance of this template can be constructed for each data item. The template is then populated with the data and returned to the initiating action. Additionally, there are listeners, such as array proxies, that monitor and update the UI produced by the inflation manager whenever changes arise.
  • Static inflation manager – this approach also employs static templates to populate data, subsequently producing the UI for a dataset. However, in this instance, there are no listeners, meaning the UI doesn’t update automatically. This method is ideal for situations where you aim to produce static content from data and desire precise control over when modifications are executed, if ever.
  • Templates manager – this class generates templates intended for system use, such as by the inflation manager. It oversees a template store where each template is cataloged and accessed by a designated name. These templates can be sourced from a file, given a file reference, or derived from an existing UI element.
  • Translations manager – this holds both a translation key and its corresponding value, commonly employed in UI labeling. Only a single translation is retained in memory. Upon startup, it’s essential to ascertain the working language and load its respective translations. These translations are then stored in the translation manager, ready for use in binding expressions.
  • Value converters manager – this manager allows you to register various value converters. While it maintains these in a store, it also facilitates straightforward conversion of values from one data type to another. For instance, if you possess a date value and wish to display it in a specific format, yet also want the capability to revert it to its original form, this manager provides that functionality.


In the context of a binding engine, especially when dealing with markup-based UIs like HTML, parsers play a pivotal role. A parser scans and interprets the markup to determine how the binding engine should behave. Based on the markup’s content, the parser establishes specific execution points for the binding engine. This step is initiated when the UI loads and is crucial because the actions and functionalities your application can perform hinge on the parser’s findings. Essentially, the parser sets the stage for how the binding engine interacts with the UI, ensuring the right actions occur in response to user interactions or data changes.

In crs-binding there are four parsers each focusing on their own concerns.

  • Elements parser – these traverse the UI hierarchy, and for every element discovered, the parsing task is delegated to the element parser.
  • Element parser – this inspects each element to determine if there are specific bindings defined for that element. It also extracts attributes from the element and directs them to the attributes parser.
  • Attributes parser – this handle a collection of attributes, delegating the parsing of each individual attribute to the attribute parser.
  • Attribute parser – this examines a specific attribute and determines the necessary binding actions associated with it. In this phase, the attribute parser recognizes the needed provider to support this functionality and invokes the provider to generate the essential executable resources.

The parsers required will largely hinge on the nature of the markup. Crucially, it’s essential to employ the separation of concerns principle, ensuring each parser remains straightforward and readily testable. This approach not only streamlines the parsing process but also enhances maintainability and reliability.

Parsing is a vital precursor to binding, so it’s imperative to optimize its speed. Where feasible, employ multithreading to minimize potential bottlenecks. This phase is inherently sensitive to the specific subject matter, and meticulous attention should be directed towards maximizing memory utilization and performance.


Providers serve as the backbone of the binding engine. They’re registered within the binding engine, dictating its range of capabilities. While we won’t delve into each provider in depth within this section, I aim to offer a broad understanding of their functionality and their integral role within the system.

All providers are:

  1. Singleton classes
  2. Expose a defined interface
    • parse – analyze either an element or attribute and establish the necessary execution points for the binding engine. During this stage, the execution plan is formulated and stored, ready to be implemented when relevant.
    • update – refresh the UI to reflect the values present in the binding context. The previously formulated plan is retrieved and then carried out.
    • clear – this is activated when an element is no longer bound or needs disposal. It ensures that any bindings associated with that element, pertaining to this provider’s context, are properly cleared.
  3. Event based providers also expose
    • get intent – this is for internal operations, aiming to retrieve the provider’s intent definition, allowing the subsequent execution of that intent. Its public accessibility ensures that different providers can cross-reference, enhancing adaptability.
    • on event – triggered when specific UI events are activated and if the intent designates a particular provider as its executor. This method is then invoked to further the process and carry out the intent.

      example: suppose a button features a click event that calls the “greet” function within the binding context. When a user activates this button, the “.call” provider examines the intent associated with the button through the binding.

Providers are initialized and registered with the binding engine upon startup. It’s crucial for the binding engine to maintain adaptability, allowing users to register additional providers as needed. This approach facilitates the integration of custom features without imposing additional development burdens on the binding engine itself.

In crs-binding, providers are cataloged using a lookup table. The table’s key represents the expression in the markup needed to pinpoint the provider. Initially, the corresponding value is the pathway to the provider file, which remains unloaded at first. This setup guarantees that providers are instantiated only when they are truly needed.

crs-binding providers lookup example

When the parsing process detects a need for a specific provider, it liaises with a provider mediator class. This intermediary verifies whether the necessary provider has already been initialized. If not, it takes the initiative to do so before progressing. Subsequently, it facilitates the communication between the parsers and the provider as demanded.

Lets look at a simple example.


The attribute parser identifies a binding expression associated with an attribute due to the presence of the “.” in the attribute name “”. It then requests the “.call” provider from the providers manager. If the provider hasn’t been instantiated yet, the manager does so. Subsequently, the “parse” method of the provider is invoked for that specific attribute, leading to the creation and storage of the intent. When the button is activated, the “.call” provider’s “onExecute” method gets triggered. This method retrieves the predefined intent, which in this scenario is a directive to invoke the “greet” function on the binding context. Following this, the “greet” function is executed.


Proxies are valuable tools when the objective is to augment an existing class with additional features. In the context of crs-binding, we leverage the repeat-for provider to display a collection on the UI. When items are removed from an array, it’s essential to also eliminate them from the UI, and when new items are added to the array, they should be reflected on the UI. To manage this, we employ an array proxy.

Working hand in hand with the array proxy is the DOM collection manager. This manager is designed to mirror the methods of an array, ensuring a direct one-to-one correspondence between array actions and the operations of the DOM collection manager.

Take, for instance, the “push” function of an array, which appends a data item to its end. Similarly, the DOM collection manager possesses a “push” function. When invoked, it appends the corresponding data item to the tail end of a DOM element’s children.


Stores is an architectural pattern for managing and optimizing interactions within a system, particularly around events and elements. The use of in-memory stores as lookup tables is an efficient way to manage system interactions.

Let’s break down the design and its advantages:

  1. Event Store:
    • Lookup Table: Enables fast lookups based on event type. This is important because, in systems with numerous events, iterating over all events to find the relevant ones would be inefficient.
    • Separation of Concerns: As a singleton, the event store only manages event resources. It doesn’t dictate how these events should be processed or used, making it modular and reusable.
  2. Element Store:
    • UUID for Elements: Marking an element with a UUID ensures a unique and consistent reference. This is particularly valuable in systems where elements might have dynamic or similar attributes, which could lead to ambiguities.
    • Performance: Referring to an element by its UUID and using it as a key for lookups is much faster than searching for an element by its attributes or properties.
    • Memory Management: Using weak references ensures that once an element is no longer in use or relevant, it doesn’t linger in memory, leading to potential memory leaks. By maintaining a centralized lookup table, cleaning up becomes a simpler task of just removing the element from the store.


  • Efficiency: In-memory lookups are significantly faster than, for example, database queries. This is particularly important for systems that need real-time interactions.
  • Modularity: By ensuring that each store has a clear and distinct responsibility, you’re promoting a modular design where each store can be developed, maintained, and potentially replaced without affecting the others.
  • Memory Leak Prevention: Centralized management of elements and events, combined with the use of weak references, ensures that memory is used optimally, and potential memory leaks are minimized.
  • State Management: The ability to serialize the stores means that you can maintain state across sessions, which is vital for applications where continuity is essential.

Given the described design, it’s clear that this architecture promotes efficiency, modularity, and robust memory management. However, when implementing such a system, it’s essential to ensure that the in-memory stores are well-optimized for large datasets and that there’s a mechanism in place to handle potential data loss (since in-memory data can be volatile). Backup or periodic serialization might be a good strategy in such cases.


Data input often requires specific validation rules. These rules might dictate data patterns, mandatory fields, or range constraints. Validating data on the client side before sending it to the server is crucial. While basic validations are essential, real-world scenarios sometimes demand more sophisticated, conditional validations.

Conditional validation hinges on a specific condition being met. Only when this condition holds true does the associated validation rule come into play. Take, for instance, the requirement that if a user’s first name is “John”, their last name should be “Doe”.

A competent binding engine should accommodate both straightforward and intricate validation scenarios. If any validation fails, it’s crucial to provide clear visual feedback to the user. An effective approach could involve coupling style expressions with validation rules. For instance, if a user inputs “John” as the first name but omits “Doe” as the last name, the corresponding input field could turn red to signal the error.


Key Principles for a Robust Binding Engine:

  1. Flexibility & Extensibility:
    • Allow extensions via external addons, enabling users to tailor the engine to specific needs.
  2. Security:
    • Ensure all expressions are sanitized to prevent injection attacks or unintended side effects.
  3. Performance & Efficiency:
    • Ensure swift response times, particularly during real-time interactions.
    • Efficient memory use to handle large datasets and complex UIs.
  4. Modularity & Loose Coupling:
    • Design the engine with modular internals, promoting independent development and testing of each component.
    • Advocate for the separation of concerns, where each module has a distinct purpose.
  5. Optimized Resource Management:
    • Adopt a “load-on-demand” strategy: only load the parts actively in use, reducing memory overhead.
    • Implement lazy loading: dynamically load features as they are required, ensuring the system remains lightweight and agile.