Concurnas is useful for those working in finance for the following reasons and more!
The syntax of Concurnas is greatly inspired by languages such as Python - which is widely recognized as one of the easiest programming languages to learn.
We have built Concurnas as an end to end solution, with code that can be used from prototype to production. This is possible due to the support built into Concurnas for scientific computing and general enterprise computing. In this way using Concurnas reduces cost, the scope for errors and time to market over the conventional model of having to use different programming languages and possibly different teams for research and production.
Dynamically typed languages are often easy to learn but come with a performance penalty, not so with Concurnas as it runs upon the Java virtual Machine (JVM), thus giving you access to the phenomenal high performance of the JVM.
Developers working with dynamically typed languages will often extol their benefits for working in a rapid development environment, unfortunately these benefits often wear off as code grows and comes to be used by a team or multiple teams. This tends not to be the issue with statically typed languages and this is where Concurnas fits in with its static typing backed by type inference which allows most code to be expressed in a dynamic way, without types, but with all the benefits of those types.
Concurnas is a null safe language. The null pointer exception is the bane of many a programmers existence and one of the most common errors to occur (often in production!), Concurnas incorporates a nullability constraint as part its type system and a number of tools for managing nullable state. It is through this means that null pointer exceptions are virtually eliminated and we can have greater confidence in the software produced.
Concurnas has first class citizen support for GPU computing. This is especially useful for performing the derivatives calculations, machine learning and optimization at the core of most trading operations. With GPU computing it's often possible to achieve computational speed ups of over two orders of magnitude (100x) vs conventional single core CPU computation. Concurnas is able to achieve this whilst allowing code to be written in idiomatic Concurnas, meaning that it's not necessary for one to switch into C/C++ to perform GPU computation, thus making GPU computation accessible for non software engineers.
Concurnas has built in support for Off heap memory. This makes it very easy to work with large data sets which cannot otherwise fit in memory all at the same time.
The off heap map support is particularly useful for managing large reference data sets, for instance, describing customer trading settings, settlement limits/instructions etc
Concurrent programming is hard, yet a necessary part of modern enterprise software development, particularly within the finance industry where we are either having to make full use of the available hardware presented to us or building software which needs to operate on a concurrent basis intrinsically - for instance a trading system. With Concurnas we have taken the hard work out of concurrent computing and presented a model which relies upon sharing of state via message passing as opposed to shared memory. This makes concurrent programming accessible to non software engineers whilst not sacrificing performance or functionality
Reactive programming provides an alternative model of computation from the traditional imperative paradigm. Instead of pulling data into our calculations we can setup a calculation like an electronic circuit and instead have our dependencies flow into that calculation. This presents a natural and intuitive way of implementing algorithms and is particularly useful for those which need to react to concurrent non deterministic flows of data. The reactive programming presented within Concurnas is like the Observer pattern except on steroids!
It turns out that the reactive model of programming is really useful for building trading systems and implementing trading models. We can take things like multiple sources of market data, a trading objective, calculated streams of data, reference data and other data changing in realtime and plug them into reactive circuits. Those circuits will then be automatically triggered for computation as appropriate when their input parameters change, perhaps triggering a trading operation, implementing a check or notifying a user etc.
Furthermore those same circuits can be used for back testing of trading models. This again means that one does not need two or more separate code bases, two or more different teams, two or more different programming languages! Instead one can use Concurnas as an end to end solution from trading model inception to production.
Concurnas, by virtue of the fact that it runs upon the JVM, can be run along side and utilize existing Java based software. One can integrate Concurnas into one's system at a measured pace, no big bang rewrite of the entire software stack is necessary! This greatly reduces risk and time to market.
Financial institutions are often reluctant to make use of innovative new technologies due to the threat of security vulnerabilities. The good news with Concurnas is that, since it runs upon the JVM, it is as secure as conventional Java. If your organization uses Java (which it almost certainly does) then it will be able to run Concurnas without any more approval than when using any Java library downloaded from the Internet.
Concurnas is free and open source, licensed under the popular and permissive MIT license.
Concurnas Ltd. was established in 2018 as a commercial entity in order to support the ongoing development of the Concurnas programming language as open source and to provide commercial support for Concurnas and consulting
We are able to provide support at multinational level which includes a number of features such phone/skype support, priority bug Fixes with a fixed response window and long term support for older versions of Concurnas.