Explore our thinking about Custom Software Development

Discover how IPC and Expero revolutionized voice trading with Here™. Learn about their journey from concept to deployment and how a modernized OneView Portfolio enhanced the trader experience.

Watch our webinar and learn to modernize finance desktops with FDC3 & OpenFin. Streamline development, enhance UX, and future-proof apps.

Connected Jetpack: An AI-assisted analytics module for navigating complex data and generating actionable insights!

Listen as guests join us from OpenFin and Microsoft to discuss how AI is influencing the financial desktop and what new technologies are on the rise.

The webinar will delve into key considerations when designing front-end applications for capital markets, including how to incorporate real-time data visualization and analysis.

The second webinar in a series on the future of the financial desktop. We will identify how to unlock new technology and show how ML techniques can be used with existing technology to drive productivity.

During this panel discussion with industry experts on how the future of the financial desktop is evolving, we talk through different ways enterprises and solution providers should be thinking about their desktop strategies.

Get a quick look at the Expero connected toolkit for finance with OpenFin. Explore the market and company overview panels, and see how these integrated feeds allow one to view multiple sources of data when reviewing assets.

In this talk we’ll discuss patterns and anti-patterns from real-world projects including: how to split your application into components, using components in data & analytics for agility, enabling users to configure and “no-code” their own applications, and how components help to sequence a modernization program.

The focus of this webinar is to show you how new technology trends in 2021 can increase the usability and accuracy of your finance analytics.

Delve into the dashboard capabilities of Expero's Financial Services Toolkit, used for portfolio analysis and recommendation, compliance information, and team sharing workflows.

Take a deeper look into how Expero's Financial Services Toolkit widgets are built, including: balancing through trade, running 'The Art of the Possible' scenarios, and compliance interactions with Jupyter Notebook.

This webinar offers a closer look at OpenDoor and how it works for its users, and insight as to how the product was made, usability, product, and software challenges that brought it to life as presented by Expero and OpenFin.

The focus of this webinar is to share some of the important design and technology factors that enable you to build successful front- and middle-office applications.

Real World Platform & UX Design for the Modern Financial Desktop

Getting your graph to scale is only half the battle. Learn here how Expero helps businesses understand their data and make real time decisions using custom visualizations and UX.

Building data products in your organization to realize data science ROI and never before seen data insights.

What makes Svelte a different UI framework and why you should give it a try. In this article you will learn the benefits of using Svelte, the new (and different) UI framework, as opposed to others like React, and Vue.

Structured Finance investors often miss opportunities to maximize portfolios due to a lack of state of the art tools and processes.

Use Keylines to increase customer loyalty from within your graph database.

Neo4j, DataStax Graph and Janus property graph schema design decisions for vertex and edge definitions.

Congratulations, you have identified what software products to modernize and you have identified what cloud technology you need to use for the upgrade! Now what? Join us to identify how to get your business case and modernization project funded.

Moving to a public or private cloud can dramatically reduce operational costs and speed up delivery of key features. But how do you get there from here? In this seminar we’ll jump into pragmatic ways to improve the way legacy applications are built and deployed as well as how to take an incremental approach to modernize those applications.

Is your software built on sunsetting technology like VB6, .NET, etc? Do you have low user satisfaction because of outdated software? Does it take too long to develop and roll out new features? Are you losing ground to solutions that offer mobile versions? Is it becoming difficult and expensive to maintain staff with legacy knowledge? Is your on-premise legacy infrastructure costly to maintain?

In this session of our client-server to cloud seminar series, we share proven methods for determining if modernizing makes sense for your application, a checklist of considerations, and a Lean process for creating a sound modernization strategy.

As a user researcher, I’m always inclined to say, “Test everything, all the time!” when people ask, “What/when/how should we validate with users?” That’s my pie in the sky: the place where there’s all the time and all the budget in the world to get every last detail or spec just right for the good of the user, the product, and, ultimately, the business. But that’s not real life. Projects run on strict budgets and tight timelines, and there’s not always a lot of wiggle room.

Congratulations! Your data is up and running in a graph database and you have big plans for this technology. But now the system is overtaxed and not performing properly. Don't worry- the database may not be the culprit. Proper user experience and visualization techniques can greatly improve performance and dynamic data interaction.

Using Google gRPC and Apache Cassandra to create a high-performance data pipeline for storing time series data that comes from IoT-style applications.

If your application does anything interesting, it has secrets. No, not that no one remembers how your code works, or that that one dev put a curse word in his checkin once. Not those kind of secrets. We’re talking about database passwords, secret API keys, per-user encryption keys, and the like. For a long time, web developers put those in configuration files or read them from files which programmers promised never to accidentally check in. Cross your heart.

In this post we are going to explore a slightly more complicated yet common scenario involving continuous deployment of a .NET web application.

In this post we will examine a simple scenario involving the deployment of a .NET based web application to an Azure Web App using Azure Key Vault for secrets management. All the code used for this blog post can be found here.

Everyone gets delusions of grandeur!” That’s what Han Solo said after being frozen in carbonite. I’ve been solving data problems for customers the last year and a half and am now getting back in graph DBMSs. We took a nice look at Titan last week, can’t wait to play with that some more. I’m going to give a bit of the same to Neo4j. All of this as prep for my talk at GraphDay 2016 in Austin, TX.

As part of the work we’re doing to refresh our graph database evaluation for a couple of clients (and our upcoming talk at Graph Day!) we took Titan 1.0out for a spin last week. We’ll be doing more in-depth explorations on some in-house and public datasets over the next few weeks, but here’s some preliminary impressions based on a contrast with the Titan we came to know a year ago or so.

ISPC Performance

Julia Performance

This the third post in a series, which started with a description of the problem, and continued with an F# benchmark.

There is still a substantial gap between this result and the result we’ll find with other environments, and my guess is this is a code generation issue, i.e. instruction selection and scheduling, but I’m not an expert in this area either!

Reactive Synchronized UI Components: how I learned to stop worrying and love synchronized maps and cross-sections.

Recently I’ve come across the need to use an ambient logical context that would automatically flow with my program logic as it jumps from thread to thread. The .NET Framework has support for this when you are working with Threads and Tasks. It is not well documented, but it Just Works…mostly.

One of ZooKeeper’s nice features is the ability to set up a watch on a node, and be updated whenever it changes.

ZooKeeper’s “native” client APIs are C and Java. If you’re programming in .NET (or Python, or a few other languages), the docs helpfully point out that some friendlies have programmed clients that “might” work for you. “Might” is frustrating, as is the possibility that the libraries are behind. So we used the Java version anyway, and made it a little more idiomatic .NET. It turns out to be a nice look at how to use Java from .NET, and how to implement Task and IObservable patterns by by hand.

Okay, so you’re sold on using ZooKeeper to be your service locator or configuration repository. Your services will all talk to ZooKeeper when they start up to find out who they are, who their neighbors are, and generally how to get on with all the other animals at the zoo. But what service locator do you use to find out where ZooKeeper itself is? (ZooKeeper is actually in one or more places, since it typically runs on multiple servers in a production environment.) The answer probably depends on the scope of your problem: a 10,000 node cluster will be different than a few dozen services. Your best options are drawn from the service locator patterns already built into your OS or environment. Here we’ll talk about 3 options.

In the last post, we used ZooKeeper as a service registry. When services started, they registered with ZooKeeper at a pre-agreed place. (/services/{dataset-name}). Clients could list the data servers available and decide which ones to connect to, or request that new ones could be launched. Thanks to ephemeral nodes, servers can crash and their registry entries are automatically deleted. Today we’ll talk about three use cases for watching changes in ZooKeeper.

Zookeeper is a distributed database originally developed as part of the Hadoop project. It’s spawned several imitators: Consul, etcd, and Doozerd (itself a clone of chubby.) A lot of the material out there about Zookeeper describes just how it works, not necessarily what you’d use it for. In this series of posts, we’ll cover how we used it at one client — and it how it also got abused.

A good development team will already have a battery of tests in place to ensure their code is correct and can be refactored safely.

Especially early in product development, small custom-built datasets are the order of the day.

Most development is feature driven. A developer is on the line to complete a user story or functional requirement, and even if the application gets a little slower, she’d rather have a demo to show during sprint review, instead of watching every one else’s demo.

How many times has a customer come and told you your product was “slow”? In this multi-part series, we will discuss how “slow” happens, and how you can fix it.

Unit of measure conversions are a constant concern in scientific code. Most well written scientific domain kernels should be unit un-aware because the equations of nature are generally unit invariant: momentum is mass times velocity whether velocity is in meters per second or furlongs per fortnight. But there are always important places where the actual values matter: water boils at 100 degrees Celsius. Therefore one typically assumes a set of canonical units in the computational domain to make the programming more straightforward. It’s also more efficient and numerically stable to only translate units on the boundaries of the computation domain, rather than littering them throughout.

Recently I was working on a GUI that walked the user through a series of 5 steps in a Workflow. The user would spend most of their time on the 3rd step. As the user made edits, those edits would immediately be sent to the server for processing, and results from the server would show up in a different part of the GUI. There was a requirement that whenever the user left the 3rd step, we needed to send a message to the server to commit the changes they’d made.

When working with RxJs and Knockout, there will be times when you have an Rx Observable and need a Knockout observable so you can bind it to a view. And there will be times when you have a Knockout observable and need an Rx Observable so you can merge several event sources or some other type of logic that is more easily solved by the RxJs linq operators.

When writing a complex single page web application, you find yourself dealing with A LOT of asynchronous activities. The user is busy clicking on UI elements and typing in text boxes. Asynchronous requests and responses are flitting back and forth between the server and client. Perhaps you’ve even got asynchronous messages coming from web workers.

Back in the 1990s, if you wanted to interview a C++ programmer, you’d ask him to write a string class. My programming homework counted words or wrote versions of grep(1). Perl made one form of regular expressions popular with the masses.That’s what you cut your teeth on. Now most every language you learn to program in has a Unicode-compliant standard string library which most people don’t think much about anymore. For most of us, it’s a solved problem. (Though there are fun exceptions.)

This post explores Alternative Investments: Part 2

This post explores Alternative Investments: Part 3

This post explores Bond Trading Platform Software.

Iconixx legacy code base and user experience once cutting edge had become dated. They were concerned that the dated look and lack of mobile options could make them vulnerable.

An all-in-one solution for lab process management.

OpenDoor Trading was creating a brand new product that needed to be innovative. However the trading community had long held expectations about how trading interfaces behave and low tolerance for traditional user studies and adopting new usability paradigms.

Drilling through narrow beds of hydrocarbons isn’t easy. Expero designed the user experience for a complex data-driven analytics package in just three months, enabling implementation for a time-sensitive customer.

Tasktop legacy client-server platform had a steep learning curve for deploying integrations. In addition to moving to the web, Tasktop wanted to enable a broader, less skilled user audience to configure and deploy integrations. Expero created a novel user experience for the new web-based platform that has far exceeded Tasktop’s user adoption goals!