Has anyone worked with DSLs (Domain Specific Languages) in the finance domain? I am planning to introduce some kind of DSL support in the application that I am working on and would like to share some ideas.
I am in a stage of identifying which are the most stable domain elements and selecting the features which would be better implemented with the DSL. I have not yet defined the syntax for this first feature.
Jay Fields and Obie Fernandez have written and talked extensively on the subject.
You'll also find general stuff on implementing DSL in Martin Fowler's writings (but not specific to finance).
Financial contracts have been modeled elegantly as a DSL by Simon Peyton Jones and Jean-Marc-Erby. Their DSL, embedded in Haskell, is presented in the paper How to write a financial contract.
Jay Fields and Obie Fernandez have written and talked extensively on the subject.
You'll also find general stuff on implementing DSL in Martin Fowler's writings (but not specific to finance).
Domain specific languages (DSLs) are most commonly used to represent financial instruments. The canonical paper is Simon Peyton Jones' Composing Contracts: an Adventure in Financial Engineering which represents contracts using a combinator library in Haskell. The most prominent use of the combinator approach is LexiFi's MLFi language, which is built on top of OCaml (their CEO, Jean-Marc Eber, is a co-author on the Composing Contracts paper). Barclay's at one point copied the approach and described some additional benefits, such as the ability to generate human-readable mathematical pricing formulas (Commercial Uses: Going Functional on Exotic Trades).
DSLs for financial contracts are typically built using an embedding in a functional language such as Haskell, Scala, or OCaml. The uptake of functional programming languages in the financial industry will continue to make this approach attractive.
In addition to representing financial instruments, DSLs are also used in finance for:
I maintain a complete list of financial DSLs papers, talks, and other resources at http://www.dslfin.org/resources.html.
If you'd like to meet professionals and researchers working with DSLs for financial systems, there's an upcoming workshop on October 1st at the MODELS 2013 conference in Miami, Florida: http://www.dslfin.org/
We worked on the idea of creating a financial valuation DSL with Fairmat ( http://www.fairmat.com )
-it exposes a DSL which can be used to express pay-offs and payment dependencies -it contains an extension model for creating new types of analytic and implementations of theoretical dynamics using .NET/ C# with our underlying math library (see some open source examples at https://github.com/fairmat
I think that the work of Simon Peyton Jones and Jean Marc Eber is the most impressive because of "Composing Contracts: an Adventure in Financial Engineering" and everything derived from that: "LexiFi and MLFi".
Found Shahbaz Chaudhary's Scala implementation the most attractive given that MLFi is not generally available (and because Scala as functional language is more accessible that Haskell).
See "Adventures in financial and software engineering" and the other material referenced from there.
I will dare to replicate a snipped for an idea of what this implementation can do.
object Main extends App {
//Required for doing LocalDate comparisons...a scalaism
implicit val LocalDateOrdering = scala.math.Ordering.fromLessThan[java.time.LocalDate]{case (a,b) => (a compareTo b) < 0}
//custom contract
def usd(amount:Double) = Scale(Const(amount),One("USD"))
def buy(contract:Contract, amount:Double) = And(contract,Give(usd(amount)))
def sell(contract:Contract, amount:Double) = And(Give(contract),usd(amount))
def zcb(maturity:LocalDate, notional:Double, currency:String) = When(maturity, Scale(Const(notional),One(currency)))
def option(contract:Contract) = Or(contract,Zero())
def europeanCallOption(at:LocalDate, c1:Contract, strike:Double) = When(at, option(buy(c1,strike)))
def europeanPutOption(at:LocalDate, c1:Contract, strike:Double) = When(at, option(sell(c1,strike)))
def americanCallOption(at:LocalDate, c1:Contract, strike:Double) = Anytime(at, option(buy(c1,strike)))
def americanPutOption(at:LocalDate, c1:Contract, strike:Double) = Anytime(at, option(sell(c1,strike)))
//custom observable
def stock(symbol:String) = Scale(Lookup(symbol),One("USD"))
val msft = stock("MSFT")
//Tests
val exchangeRates = collection.mutable.Map(
"USD" -> LatticeImplementation.binomialPriceTree(365,1,0),
"GBP" -> LatticeImplementation.binomialPriceTree(365,1.55,.0467),
"EUR" -> LatticeImplementation.binomialPriceTree(365,1.21,.0515)
)
val lookup = collection.mutable.Map(
"MSFT" -> LatticeImplementation.binomialPriceTree(365,45.48,.220),
"ORCL" -> LatticeImplementation.binomialPriceTree(365,42.63,.1048),
"EBAY" -> LatticeImplementation.binomialPriceTree(365,53.01,.205)
)
val marketData = Environment(
LatticeImplementation.binomialPriceTree(365,.15,.05), //interest rate (use a universal rate for now)
exchangeRates, //exchange rates
lookup
)
//portfolio test
val portfolio = Array(
One("USD")
,stock("MSFT")
,buy(stock("MSFT"),45)
,option(buy(stock("MSFT"),45))
,americanCallOption(LocalDate.now().plusDays(5),stock("MSFT"),45)
)
for(contract <- portfolio){
println("===========")
val propt = LatticeImplementation.contractToPROpt(contract)
val rp = LatticeImplementation.binomialValuation(propt, marketData)
println("Contract: "+contract)
println("Random Process(for optimization): "+propt)
println("Present val: "+rp.startVal())
println("Random Process: \n"+rp)
}
}
The excellent work of Tomas Petricek in F# is very much worth exploring.
Beyond the "DSL" paradigm I suggest we'd need contributions from a number of other powerful paradigms to have a complete way to represent the complex semantics of financial instruments and financial contracts while meeting the "big data" realities.
Worth reviewing some languages mentioned here: http://www.dslfin.org/resources.html
© 2022 - 2024 — McMap. All rights reserved.