DSL (lenguajes específicos de dominio) en finanzas

https://stackoverflow.com/questions/23448

dsl
finance

09-06-2019
|

Pregunta

¿Alguien ha trabajado con DSL (lenguajes específicos de dominio) en el ámbito financiero?Estoy planeando introducir algún tipo de soporte DSL en la aplicación en la que estoy trabajando y me gustaría compartir algunas ideas.

Estoy en una etapa de identificar cuáles son los elementos de dominio más estables y seleccionar las características que se implementarían mejor con DSL.Todavía no he definido la sintaxis para esta primera característica.

Solución

Jay Fields y Obie Fernández han escrito y hablado extensamente sobre el tema.

Introducción de Jay Fields en Idiomas específicos del dominio
La serie de Jay Fields sobre Lenguaje Natural Empresarial
Obie Fernández Expresar los términos del contrato en un DSL
Una muy buena presentación en infoQ por Jay Fields

También encontrará información general sobre la implementación de DSL en los escritos de Martin Fowler (pero no específicamente sobre finanzas).

ADSL

Otros consejos

Los contratos financieros han sido modelados elegantemente como DSL por Simon Peyton Jones y Jean-Marc-Erby.Su DSL, integrado en Haskell, se presenta en el artículo. Cómo redactar un contrato financiero.

Los lenguajes de dominio específico (DSL) se utilizan con mayor frecuencia para representar instrumentos financieros.El artículo canónico es el de Simon Peyton Jones. Redacción de Contratos:una aventura en ingeniería financiera que representa contratos utilizando una biblioteca combinadora en Haskell.El uso más destacado del enfoque combinador es Lenguaje MLFi de LexiFi, que está construido sobre OCaml (su director ejecutivo, Jean-Marc Eber, es coautor del artículo Composing Contracts).En un momento, Barclay's copió el enfoque y describió algunos beneficios adicionales, como la capacidad de generar fórmulas matemáticas de precios legibles por humanos (Usos comerciales:Volverse funcional en comercios exóticos).

Los DSL para contratos financieros generalmente se crean mediante una integración en un lenguaje funcional como Haskell, Scala u OCaml.La adopción de lenguajes de programación funcionales en la industria financiera seguirá haciendo que este enfoque sea atractivo.

Además de representar instrumentos financieros, los DSL también se utilizan en finanzas para:

Modelado de entidades financieras con lenguajes de ontología (Ontología empresarial de la industria financiera)
Reemplazar los cálculos que normalmente se describen usando hojas de cálculo (http://doi.acm.org/10.1145/1411204.1411236)
Modelado de planes de pensiones (Caso de estudio:Servicios financieros)
Análisis de datos del mercado financiero (El lenguaje del erizo)

Mantengo una lista completa de documentos, charlas y otros recursos financieros de DSL en http://www.dslfin.org/resources.html.

Si desea conocer a profesionales e investigadores que trabajan con DSL para sistemas financieros, hay un próximo taller el 1 de octubre en la conferencia MODELS 2013 en Miami, Florida: http://www.dslfin.org/

Trabajamos en la idea de crear un DSL de valoración financiera con Fairmat ( http://www.fairmat.com )

-Is expone un DSL que se puede utilizar para expresar pagos y dependencias de pagos: contiene un modelo de extensión para crear nuevos tipos de analíticos e implementaciones de dinámicas teóricas utilizando .NET/ C# con nuestra biblioteca de matemáticas subyacentes (consulte algunos ejemplos de código abierto en https://github.com/fairmat

Creo que el trabajo de Simon Peyton Jones y Jean Marc Eber es el más impresionante por "Componer contratos:una Aventura en Ingeniería Financiera” y todo lo derivado de ello:"LexiFi y MLFi".

Encontró Shahbaz Chaudhary's La implementación de Scala es la más atractiva dado que MLFi no está disponible generalmente (y porque Scala como lenguaje funcional es más accesible que Haskell).

Ver "Aventuras en ingeniería financiera y de software" y el resto del material al que se hace referencia desde allí.

Me atreveré a replicar un recorte para tener una idea de lo que puede hacer esta implementación.

  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)
  }

}

El excelente trabajo de Tomas Petricek en F# vale la pena explorarlo.

Más allá del paradigma "DSL", sugiero que necesitaríamos contribuciones de otros paradigmas poderosos para tener una forma completa de representar la semántica compleja de los instrumentos financieros y los contratos financieros y al mismo tiempo satisfacer las realidades de los "grandes datos".

Programación probabilística: Fígaro, Stan, etc.
Análisis de big data:R, chispa, chispaR
"Tejido de datos" escalable ("memoria fuera del montón";en hardware básico, sino también a través de idiomas): "DataFrames en Spark para ciencia de datos a gran escala" (funciona con R, Scala/Java y Python)
Web semántica:"Modelos de temas financieros" y ontologías.

Vale la pena revisar algunos idiomas mencionados aquí: http://www.dslfin.org/resources.html

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow