DSLs (Domain Specific Languages) in Finance

问题

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.

回答1:

Jay Fields and Obie Fernandez have written and talked extensively on the subject.

Jay Fields intro on Domain Specific Languages
Jay Fields' series on Business Natural Language
Obie Fernandez Expressing Contract Terms in a DSL
A very good presentation on infoQ by Jay Fields

You'll also find general stuff on implementing DSL in Martin Fowler's writings (but not specific to finance).

回答2:

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.

回答3:

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:

Modeling financial entities with ontology languages (Financial Industry Business Ontology)
Replacing computations typically described using spreadsheets (http://doi.acm.org/10.1145/1411204.1411236)
Modeling pension plans (Case Study: Financial Services)
Analyzing financial market data (The Hedgehog Language)

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/

回答4:

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

回答5:

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.

Probabilistic programming: Figaro, Stan, etc
Big data analytics: R, Spark, SparkR
Scalable "data fabric" ("off heap memory"; across commodity hardware but also across languages): "DataFrames in Spark for Large Scale Data Science" (works with R, Scala/Java and Python)
Semantic web: "Financial Topic Models" and ontologies.

Worth reviewing some languages mentioned here: http://www.dslfin.org/resources.html

来源：https://stackoverflow.com/questions/23448/dsls-domain-specific-languages-in-finance

标签

dsl

finance