DSL (Langages spécifiques au domaine) en finance

StackOverflow https://stackoverflow.com/questions/23448

  •  09-06-2019
  •  | 
  •  

Question

Quelqu'un a-t-il travaillé avec DSL (langages spécifiques au domaine) dans le domaine financier ?Je prévois d'introduire une sorte de support DSL dans l'application sur laquelle je travaille et j'aimerais partager quelques idées.

Je suis en train d'identifier quels sont les éléments de domaine les plus stables et de sélectionner les fonctionnalités qui seraient mieux implémentées avec le DSL.Je n'ai pas encore défini la syntaxe de cette première fonctionnalité.

Était-ce utile?

La solution

Jay Fields et Obie Fernandez ont beaucoup écrit et parlé sur le sujet.

Vous trouverez également des informations générales sur la mise en œuvre du DSL dans les écrits de Martin Fowler (mais pas spécifiques à la finance).

Autres conseils

Les contrats financiers ont été modélisés avec élégance comme un DSL par Simon Peyton Jones et Jean-Marc-Erby.Leur DSL, intégré dans Haskell, est présenté dans l'article Comment rédiger un contrat financier.

Les langages spécifiques à un domaine (DSL) sont les plus couramment utilisés pour représenter les instruments financiers.L'article canonique est celui de Simon Peyton Jones Rédaction de contrats :une aventure en ingénierie financière qui représente les contrats utilisant une bibliothèque de combinateurs dans Haskell.L'utilisation la plus importante de l'approche combinatrice est Le langage MLFi de LexiFi, qui est construit sur OCaml (leur PDG, Jean-Marc Eber, est co-auteur de l'article Composing Contracts).Barclay's a à un moment donné copié l'approche et décrit certains avantages supplémentaires, tels que la capacité de générer des formules de tarification mathématiques lisibles par l'homme (Utilisations commerciales :Devenir fonctionnel sur les métiers exotiques).

Les DSL pour les contrats financiers sont généralement construits à l'aide d'une intégration dans un langage fonctionnel tel que Haskell, Scala ou OCaml.L’adoption de langages de programmation fonctionnels dans le secteur financier continuera de rendre cette approche attrayante.

En plus de représenter des instruments financiers, les DSL sont également utilisés en finance pour :

Je maintiens une liste complète des documents, conférences et autres ressources sur les DSL financiers sur http://www.dslfin.org/resources.html.

Si vous souhaitez rencontrer des professionnels et des chercheurs travaillant avec les DSL pour les systèmes financiers, un atelier aura lieu le 1er octobre lors de la conférence MODELS 2013 à Miami, en Floride : http://www.dslfin.org/

Nous avons travaillé sur l'idée de créer un DSL de valorisation financière avec Fairmat ( http://www.fairmat.com )

-Il expose un DSL qui peut être utilisé pour exprimer les paiements et les dépendances de paiement -it contient un modèle d'extension pour créer de nouveaux types d'analyse et implémentations de la dynamique théorique en utilisant .NET / C # avec notre bibliothèque mathématique sous-jacente (voir quelques exemples open source à https://github.com/fairmat

Je pense que le travail de Simon Peyton Jones et Jean Marc Eber est le plus impressionnant grâce à « Composing Contracts :une aventure en ingénierie financière" et tout ce qui en découle :"LexiFi et MLFi".

Trouvé Shahbaz Chaudhary L'implémentation Scala est la plus attrayante étant donné que MLFi n'est pas généralement disponible (et parce que Scala en tant que langage fonctionnel est plus accessible que Haskell).

Voir "Aventures en ingénierie financière et logicielle" et les autres documents référencés à partir de là.

J'oserai reproduire un extrait pour avoir une idée de ce que cette implémentation peut faire.

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

}

Le excellent travail de Tomas Petricek en F# vaut vraiment la peine d’être exploré.

Au-delà du paradigme « DSL », je suggère que nous aurions besoin des contributions d'un certain nombre d'autres paradigmes puissants pour disposer d'un moyen complet de représenter la sémantique complexe des instruments financiers et des contrats financiers tout en répondant aux réalités du « big data ».

Cela vaut la peine de revoir certaines langues mentionnées ici : http://www.dslfin.org/resources.html

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top