Introduction to Finsemble
Finsemble is an integration platform, connecting all of your applications together—modern or legacy, in-house or third-party. This is done with little to no development work; Finsemble cuts development time to integrate separate applications from weeks or months to hours or days. The end result of these integration efforts is a cohesive desktop consisting of separate but interconnecting applications.
Finsemble provides two types of integration. The first type is visual integration. Visual integration creates form that facilitates function. All applications launched by Finsemble share an aesthetic. This look and feel is defined by your organization through easy white labeling. Each window can participate in a range of thoroughly considered, mature UX features. Windows can snap, dock, group, tile, and tab. Windows launched by Finsemble are persistent between sessions, reloading in the same position and with the same content. These capabilities are available for all applications out of the box, with zero coding.
This level of integration is important, but it's not enough. Finsemble also provides a deeper level of synthesis with logical integration. Applications communicate and work together no matter the language they're written in—even if you don't have control over the source code.
Logical integration allows you to create custom workflows. Workflows occur when Finsemble facilitates interoperation between two applications. For example, a user might share a ChartIQ chart with a client—with all data layers and annotations—through Symphony chat. Workflows can also occur when developer-created rules trigger events. For example, when a user shares a ChartIQ chart with a client over Symphony, a CRM like Salesforce can automatically log this activity for tracking purposes.
A good place to orient yourself to all the reasons we built Finsemble is the Finsemble White Paper.
If you're a developer who wants to get their hands on the code, check out the Finsemble seed project.
If you're a developer who wants a better insight into our architecture, take a glance at our tutorials—check out the Architectural Overview as a starting point.
Have questions? Reach out to email@example.com.
The User Experience
Finsemble unifies the financial professional’s desktop experience. It comes with production-ready, fully customizable modular UI.
Conceptually similar apps may be launched at the same time. Additionally, with a click, this group can "hyperfocus," which minimizes everything that isn't a part of the group.
Drag and Drop Data Sharing
Users can instantly transfer data between windows with a simple drag and drop action. For example, Salesforce contact information could be dragged into a Symphony chat.
It's hard to use keyboard shortcuts with web apps because they only capture keystrokes when the browser window has focus. Finsemble solves this issue by capturing keystrokes globally, so hotkeys can be used no matter what.
Multiple components can synchronize on a shared context. For example, linking applications together by stock symbol allows all applications to update their data automatically when the stock being viewed changes. The Linker uses a powerful but simple paradigm of colored "channels" to assign groups of components to participate in synchronization.
Users have access to a single search box that can federate search requests across multiple back-end services and display the returned data in a single result set. Results are actionable, allowing an end user to click on the result to bring up the data. For instance, searching for "Apple" could bring up results for both market data and research—a click on the results will bring up that data in a corresponding component.
Window management gives users power steering. Users can snap windows together, dock them into groups, tile them on top of each other, or tab them together.
Between sessions, Finsemble will save and relaunch correctly: all windows will be in the same position and all of their contents will be restored. End users can save multiple workspace layouts and easily switch between groups of applications for different tasks. They can also share their saved workspaces with others in their organization.
Finsemble lets developers build an application using familiar web technologies and deploy a single code base to both the browser and the desktop.
Finsemble allows developers to add an authentication component to match their specific application's needs. This includes authenticating access to the entire application or authenticating access to specific components within the application. Finsemble is agnostic about the underlying authentication mechanism, but provides both a cohesive end user UX and framework abstraction. Further, some commonly used methods are supported out of the box, such as leveraging a user’s Windows login.
Multi-window HTML5 application debugging is inherently fragmented; by default, single logical threads span multiple windows and must be tracked across multiple consoles. The Central Logger is a comprehensive dev tool that collates console messages across the entire Finsemble application.
Configuration-Based Process Splintering
Finsemble allows developers to specify which components should share a process, and under which circumstances. This allows developers to balance concurrency vs. memory footprint in an intelligent way.
The Distributed Store reduces complexity by operating as a central repository. This reduces the number of connections that windows need to maintain. The Distributed Store hosts business logic which can be invoked by any window that it’s plugged into. This lets the store synchronize state across window boundaries. Multiple windows can share data, yet remain loosely coupled.
Finsemble is designed to be inherently configurable because of one simple fact: you shouldn't build a huge system and hard code everything. Finsemble’s config can be assembled from multiple pieces, allowing you to organize your configuration logically, and Finsemble’s config is dynamic, so your application can adapt to entitlements, environments, and preferences.
Finsemble is built on an extensible microservice architecture. These microservices provide an innovative infrastructure to support large applications in elegant ways. Microservices have a smaller memory footprint. Independent, cooperating parts guarantee stability as a single error doesn't crash the application.
Finsemble ships with a set of microservices that manage core features such as workspaces, storage, or docking. Firms and third-party vendors can also add their own microservices to encapsulate their own business logic.
Finsemble makes use of pop up (toast) notifications. Developers can leverage the API so that their components can create notifications. System messages and alerts are automatically routed through the notification system. Unlike operating system notifications, these notifications can be interactive, allowing end users to click on them to take action.
Most HTML5 UI toolkits are only meant for building single page applications. Finsemble provides UI components specific to the desktop paradigm and can be recombined and extended.
For communications amongst microservices, components, or outside the container entirely, an event infrastructure provides high level protocols. At the center of this functionality is the Router API. Three abstractions are provided: Listen/Transmit, Query/Response, and SubPub. The Router API integrates directly with the Inter-Application Bus so that native applications can fully participate.
Finsemble provides a persistence framework for connecting to external persistent storage (i.e., databases, tuple stores, etc.). Workspaces, windows state, and other Finsemble functions automatically use the persistence framework, eliminating the need for hand wiring. Components can use the storage API to save and restore state, ensuring that they are reconstituted appropriately during workspace reloads.
Finsemble breaks UI components down into individual "controls": atomic-level UI building blocks which you can use to build your own componentry, or customize the built-in componentry. This goes far beyond simple theming and allows for true UI extensibility.
Finsemble comes with CSS files designed to simplify the process of white labeling the UI. The CSS has been carefully crafted with semantically meaningful variables. Developers can easily change font, color, and general appearance of interface sections by overriding any of a number of core variables. For deeper stylistic changes, Finsemble makes provisions for overriding any CSS style as part of the build configuration.
Finsemble dramatically simplifies the process of building a single application from separate components.
Assimilate Legacy Applications
Incorporate native applications into a Finsemble workspace using only configuration—no code changes or code control required. Once assimilated, native apps behave like any other Finsemble component, obeying layout, window management, and workspace management rules.
Integrate HTML5 Applications
Finsemble allows deep integration of web apps into your desktop experience. This can be done even when you do not have the ability to make code changes to the component. Critically, this allows a developer to “Finsembelize” a web-deployed application without changing how it is deployed to browsers. Finsemble-specific code is injected on-the-fly when the application is loaded onto the desktop. Workspace integration, symbol linking, and deep workflow integration (e.g., sharing data across the Router, pre-populating forms, automating tasks) are all possible without making code changes. This dramatically reduces integration times while reducing regression risk for stable assets.