redes - que es dsl modem

DSL en Finanzas

Question

¿Alguien aquí ha trabajado alguna vez con DSL (Idiomas Específicos de Dominio) en el dominio de las finanzas? 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 la función que se implementaría mejor con el dsl. Todavía no he definido la sintaxis para esta primera función.

Agradezco cualquier consejo

Gustavo

Answer 1

Jay Fields y Obie Fernandez han escrito y hablado extensamente sobre el tema.

• Intro de Jay Fields en lenguajes específicos del dominio
• Serie de Jay Fields sobre el lenguaje natural empresarial
• Obie Fernandez expresando 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).

• DSL

Answer 2

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 documento Cómo redactar un contrato financiero .

Answer 3

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

-expone una DSL que puede usarse para expresar cancelaciones y dependencias de pago -contiene un modelo de extensión para crear nuevos tipos de análisis e implementaciones de dinámica teórica usando .NET / C # con nuestra biblioteca matemática subyacente (vea algunos ejemplos de código abierto) en https://github.com/fairmat

Answer 4

Los lenguajes específicos de dominio (DSL) se usan más comúnmente para representar instrumentos financieros. El artículo canónico es Contratos de composición de Simon Peyton Jones : una aventura en ingeniería financiera que representa contratos usando una biblioteca combinatoria en Haskell. El uso más destacado del enfoque combinador es el lenguaje MLFI de LexiFi , que se basa en OCaml (su director ejecutivo, Jean-Marc Eber, es coautor del documento de composición de contratos). En un momento, Barclay copió el enfoque y describió algunos beneficios adicionales, como la capacidad de generar fórmulas de precios matemáticos legibles por los humanos ( Usos comerciales: Funcionalidad funcional en los comercios exóticos ).

Las DSL para contratos financieros normalmente se crean utilizando una incrustación en un lenguaje funcional como Haskell, Scala u OCaml. La adopción de lenguajes de programación funcionales en la industria financiera continuará haciendo este enfoque atractivo.

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

• Modelado de entidades financieras con idiomas de ontología ( Financial Industry Business Ontology )
• Reemplazar los cálculos descritos típicamente usando hojas de cálculo ( http://doi.acm.org/10.1145/1411204.1411236 )
• Modelado de planes de pensiones ( Estudio de caso: Servicios financieros )
• Analizando los datos del mercado financiero ( The Hedgehog Language )

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

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

Answer 5

Creo que el trabajo de Simon Peyton Jones y Jean Marc Eber es el más impresionante debido a "Contratos de composición: una aventura en ingeniería financiera" y todo lo derivado de eso: " LexiFi y MLFi ".

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

Consulte "Aventuras en ingeniería financiera y de software" y el otro material al que se hace referencia a partir de allí.

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

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

Vale la pena explorar el excelente trabajo de Tomas Petricek en F #.

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

• Programación probabilística: Figaro , Stan, etc.
• Big data analytics: R, Spark, SparkR
• "Estructura de datos" escalable ("memoria extraíble ", a través del hardware básico pero también en todos los idiomas ): "DataFrames en Spark para ciencia de datos a gran escala" (funciona con R, Scala / Java y Python)
• Web semántica: " Modelos temáticos financieros " y ontologías.

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