DSLs (Domänenspezifische Sprachen) im Finanzwesen
Frage
Hat jemand damit gearbeitet? DSLs (Domänenspezifische Sprachen) im Finanzbereich?Ich plane, in der Anwendung, an der ich arbeite, eine Art DSL-Unterstützung einzuführen, und möchte einige Ideen mitteilen.
Ich bin gerade dabei, die stabilsten Domänenelemente zu identifizieren und die Funktionen auszuwählen, die mit dem DSL besser implementiert werden könnten.Ich habe die Syntax für diese erste Funktion noch nicht definiert.
Lösung
Jay Fields und Obie Fernandez haben ausführlich zu diesem Thema geschrieben und darüber gesprochen.
- Jay Fields Einführung zu Domänenspezifische Sprachen
- Jay Fields‘ Serie weiter Natürliche Geschäftssprache
- Obie Fernandez Vertragsbedingungen in einem DSL ausdrücken
- Ein sehr gutes Präsentation auf infoQ von Jay Fields
In den Schriften von Martin Fowler finden Sie auch allgemeine Informationen zur Implementierung von DSL (jedoch nicht speziell zum Thema Finanzen).
Andere Tipps
Finanzverträge wurden von Simon Peyton Jones und Jean-Marc-Erby elegant als DSL modelliert.Ihr in Haskell eingebettetes DSL wird in der Arbeit vorgestellt So schreiben Sie einen Finanzvertrag.
Domänenspezifische Sprachen (DSLs) werden am häufigsten zur Darstellung von Finanzinstrumenten verwendet.Das kanonische Papier stammt von Simon Peyton Jones Verfassen von Verträgen:ein Abenteuer im Financial Engineering die Verträge mithilfe einer Kombinatorbibliothek in Haskell darstellt.Die bekannteste Anwendung des Kombinator-Ansatzes ist Die MLFi-Sprache von LexiFi, das auf OCaml aufbaut (ihr CEO, Jean-Marc Eber, ist Co-Autor des Papiers „Composing Contracts“).Barclay's kopierte einmal den Ansatz und beschrieb einige zusätzliche Vorteile, wie zum Beispiel die Möglichkeit, für Menschen lesbare mathematische Preisformeln zu erstellen (Kommerzielle Nutzung:Bei exotischen Trades funktionsfähig werden).
DSLs für Finanzverträge werden typischerweise durch Einbettung in eine funktionale Sprache wie Haskell, Scala oder OCaml erstellt.Die Verbreitung funktionaler Programmiersprachen in der Finanzbranche wird diesen Ansatz weiterhin attraktiv machen.
Neben der Darstellung von Finanzinstrumenten werden DSLs auch im Finanzwesen eingesetzt für:
- Modellierung von Finanzeinheiten mit Ontologiesprachen (Geschäftsontologie der Finanzindustrie)
- Ersetzen von Berechnungen, die normalerweise mithilfe von Tabellenkalkulationen beschrieben werden (http://doi.acm.org/10.1145/1411204.1411236)
- Modellierung von Pensionsplänen (Fallstudie:Finanzdienstleistungen)
- Analyse von Finanzmarktdaten (Die Igelsprache)
Ich führe eine vollständige Liste der Finanzpapiere, Vorträge und anderen Ressourcen zu DSLs unter http://www.dslfin.org/resources.html.
Wenn Sie Fachleute und Forscher treffen möchten, die mit DSLs für Finanzsysteme arbeiten, gibt es am 1. Oktober einen Workshop auf der MODELS 2013-Konferenz in Miami, Florida: http://www.dslfin.org/
Wir haben mit Fairmat an der Idee gearbeitet, eine Finanzbewertung DSL zu erstellen ( http://www.fairmat.com )
-Es enthält eine DSL, die verwendet werden kann, um Auszahlungen und Zahlungsabhängigkeiten auszudrücken. -Es enthält ein Erweiterungsmodell zum Erstellen neuer Arten von Analyse und Implementierungen der theoretischen Dynamik mit .NET/ C# mit unserer zugrunde liegenden mathematischen Bibliothek (siehe einige Open -Source -Beispiele bei https://github.com/fairmat
Ich denke, dass die Arbeit von Simon Peyton Jones und Jean Marc Eber wegen „Composing Contracts“ am beeindruckendsten ist:an Adventure in Financial Engineering“ und alles daraus abgeleitete:"LexiFi und MLFi".
Gefunden Shahbaz Chaudharys Die Scala-Implementierung ist am attraktivsten, da MLFi nicht allgemein verfügbar ist (und weil Scala als funktionale Sprache leichter zugänglich ist als Haskell).
Sehen „Abenteuer im Finanz- und Software-Engineering“ und das andere Material, auf das von dort verwiesen wird.
Ich werde es wagen, einen Ausschnitt zu reproduzieren, um eine Vorstellung davon zu bekommen, was diese Implementierung bewirken kann.
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)
}
}
Der ausgezeichnete Arbeit von Tomas Petricek in F# ist auf jeden Fall eine Erkundung wert.
Über das „DSL“-Paradigma hinaus schlage ich vor, dass wir Beiträge einer Reihe anderer leistungsstarker Paradigmen benötigen, um eine vollständige Möglichkeit zu haben, die komplexe Semantik von Finanzinstrumenten und Finanzverträgen darzustellen und gleichzeitig den „Big Data“-Realitäten gerecht zu werden.
- Probabilistische Programmierung: Figaro, Stan usw
- Big-Data-Analyse:R, Funke, SparkR
- Skalierbare „Datenstruktur“ („Off-Heap-Speicher“;über Standardhardware hinweg, aber auch über Sprachen hinweg): „DataFrames in Spark für groß angelegte Datenwissenschaft“ (funktioniert mit R, Scala/Java und Python)
- Semantisches Web:"Finanzielle Themenmodelle" und Ontologien.
Es lohnt sich, einige hier erwähnte Sprachen zu überprüfen: http://www.dslfin.org/resources.html