Your SlideShare is downloading. ×
F# in the enterprise
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Introducing the official SlideShare app

Stunning, full-screen experience for iPhone and Android

Text the download link to your phone

Standard text messaging rates apply

F# in the enterprise

887
views

Published on

An F# presentation that I did for an investment bank.

An F# presentation that I did for an investment bank.

Published in: Technology

0 Comments
2 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
887
On Slideshare
0
From Embeds
0
Number of Embeds
3
Actions
Shares
0
Downloads
5
Comments
0
Likes
2
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide
  • Credit Suisse – rapid development or modelsGrange Insurance - order of magnitude speed increase, running what if scenarios, parrellismEon Energy Trading – pluggable calculation enginesXbox live – Multi-Terrabyte parsing and analytics
  • Transcript

    • 1. DaveThomas
    • 2.  First class .Net Language citizen  Multi paradigm language  Functional  Object orientated  Well suited for:  Financial  Statistical  Testing  Event processing  Tool development  General purpose components  General server-side development
    • 3.  Referential transparency / deterministic  Immutability  First class functions  Higher order functions  Recursion
    • 4.  Reasoning  Code behaves in a consistent understandable manner  Safety  Contents of variables are always as expected no unknown mutation  Reduction code  Code can be safely reused  Data Sharing  Threading is easier and locks are no longer needed  Testing  Concise functions that are easy to test
    • 5.  Code reduction  Typically around 70%  Increased performance  Easy to parallelise functions  Increased productivity  Common to experience 50% boost  Increasing importance of multi-core and cloud  F# facilitates building multi-core friendly code  Reduced maintenance costs  Bugs and compiler issues are found earlier, typically during REPL (Read-Eval-Print Loop is for interactive compilation and exploration)  Easy to create Domain specific languages
    • 6.  Financial services  Credit Suisse –Valuation, Quant models  Insurance rating  Grange insurance – Insurance Rating Engine  Energy trading  Eon EnergyTrading – pluggable calculation engines  Statistical analysis  Xbox live (TrueSkill)
    • 7.  C# already had functional features  LINQ, Lambda expressions, predicates, closures  Uses the same .Net libraries  Can be consumed by other .Net languages  Start with core components  Algorithm development  Data analysis  parallel batch processing  rapid prototyping  Testing
    • 8. Object pool -C# Example taken from the MSDN website 2Types 20 Lines in base class 41 lines in derived class using System.Collections.Generic; using System.Diagnostics; namespace System.Collections.Concurrent { /// <summary>Provides a thread-safe object pool.</summary> /// <typeparam name="T">Specifies the type of the elements stored in the pool.</typeparam> [DebuggerDisplay("Count={Count}")] [DebuggerTypeProxy(typeof(IProducerConsumerCollection_DebugView<>))] public sealed class ObjectPool<T> : ProducerConsumerCollectionBase<T> { private readonlyFunc<T> _generator; /// <summary>Initializes an instance of the ObjectPool class.</summary> /// <param name="generator">The function used to create items when no items exist in the pool.</param> public ObjectPool(Func<T> generator) : this(generator, new ConcurrentQueue<T>()) { } /// <summary>Initializes an instance of the ObjectPool class.</summary> /// <param name="generator">The function used to create items when no items exist in the pool.</param> /// <param name="collection">The collection used to store the elements of the pool.</param> public ObjectPool(Func<T> generator, IProducerConsumerCollection<T> collection) : base(collection) { if (generator == null) throw new ArgumentNullException("generator"); _generator = generator; } /// <summary>Adds the provided item into the pool.</summary> /// <param name="item">The item to be added.</param> public void PutObject(T item) { base.TryAdd(item); } /// <summary>Gets an item from the pool.</summary> /// <returns>The removed or created item.</returns> /// <remarks>If the pool is empty, a new item will be created and returned.</remarks> public T GetObject() { T value; return base.TryTake(out value) ? value : _generator(); } /// <summary>Clears the object pool, returning all of the data that was in the pool.</summary> /// <returns>An array containing all of the elements in the pool.</returns> public T[] ToArrayAndClear() { var items = new List<T>(); T value; while (base.TryTake(out value)) items.Add(value); return items.ToArray(); } protected override boolTryAdd(T item) { PutObject(item); return true; } protected override boolTryTake(out T item) { item = GetObject(); return true; } } } /// <summary> /// Provides a base implementation for producer-consumer collections that wrap other /// producer-consumer collections. /// </summary> /// <typeparam name="T">Specifies the type of elements in the collection.</typeparam> [Serializable] public abstract class ProducerConsumerCollectionBase<T> : IProducerConsumerCollection<T> { private readonlyIProducerConsumerCollection<T> _contained; /// <summary>Initializes the ProducerConsumerCollectionBase instance.</summary> /// <param name="contained">The collection to be wrapped by this instance.</param> protected ProducerConsumerCollectionBase(IProducerConsumerCollection<T> contained) { if (contained == null) throw new ArgumentNullException("contained"); _contained = contained; } /// <summary>Gets the contained collection.</summary> protected IProducerConsumerCollection<T>ContainedCollection { get { return _contained; } } /// <summary>Attempts to add the specified value to the end of the deque.</summary> /// <param name="item">The item to add.</param> /// <returns>true if the item could be added; otherwise, false.</returns> protected virtual boolTryAdd(T item) { return _contained.TryAdd(item); } /// <summary>Attempts to remove and return an item from the collection.</summary> /// <param name="item"> /// When this method returns, if the operation was successful, item contains the item removed. If /// no item was available to be removed, the value is unspecified. /// </param> /// <returns> /// true if an element was removed and returned from the collection; otherwise, false. /// </returns> protected virtual boolTryTake(out T item) { return _contained.TryTake(out item); } /// <summary>Attempts to add the specified value to the end of the deque.</summary> /// <param name="item">The item to add.</param> /// <returns>true if the item could be added; otherwise, false.</returns> boolIProducerConsumerCollection<T>.TryAdd(T item) { return TryAdd(item); } /// <summary>Attempts to remove and return an item from the collection.</summary> /// <param name="item"> /// When this method returns, if the operation was successful, item contains the item removed. If /// no item was available to be removed, the value is unspecified. /// </param> /// <returns> /// true if an element was removed and returned from the collection; otherwise, false. /// </returns> boolIProducerConsumerCollection<T>.TryTake(out T item) { return TryTake(out item); } /// <summary>Gets the number of elements contained in the collection.</summary> public int Count { get { return _contained.Count; } } /// <summary>Creates an array containing the contents of the collection.</summary> /// <returns>The array.</returns> public T[] ToArray() { return _contained.ToArray(); } /// <summary>Copies the contents of the collection to an array.</summary> /// <param name="array">The array to which the data should be copied.</param> /// <param name="index">The starting index at which data should be copied.</param> public void CopyTo(T[] array, int index) { _contained.CopyTo(array, index); } /// <summary>Copies the contents of the collection to an array.</summary> /// <param name="array">The array to which the data should be copied.</param> /// <param name="index">The starting index at which data should be copied.</param> void ICollection.CopyTo(Array array, int index) { _contained.CopyTo(array, index); } /// <summary>Gets an enumerator for the collection.</summary> /// <returns>An enumerator.</returns> public IEnumerator<T>GetEnumerator() { return _contained.GetEnumerator(); } /// <summary>Gets an enumerator for the collection.</summary> /// <returns>An enumerator.</returns> IEnumeratorIEnumerable.GetEnumerator() { return GetEnumerator(); } /// <summary>Gets whether the collection is synchronized.</summary> boolICollection.IsSynchronized { get { return _contained.IsSynchronized; } } /// <summary>Gets the synchronization root object for the collection.</summary> object ICollection.SyncRoot { get { return _contained.SyncRoot; } }
    • 9. Agent based object pool 25 Lines of code 1Type alias 2Types F# 25 Lines 689 Characters 59% less Lines 66% less Characters C# 61 Lines 2041 Characters 2.4x more Lines 2.96x more Characters functions modulePoc //Agent alias for MailboxProcessor typeAgent<'T>=MailboxProcessor<'T> ///One of three messages for our Object Pool agent typePoolMessage<'a>= | GetofAsyncReplyChannel<'a> | Putof'a | ClearofAsyncReplyChannel<List<'a>> /// Object pool representing a reusable pool of objects typeObjectPool<'a>(generate:unit->'a, initialPoolCount) = letinitial=List.initinitialPoolCount (fun (x) ->generate()) letagent=Agent.Start(funinbox-> letrecloop(x) =async { let!msg=inbox.Receive() matchmsgwith | Get(reply) -> letres=matchxwith | a::b->reply.Reply(a);b | [] asempty->reply.Reply(generate());empty return!loop(res) | Put(value)->return!loop(value::x) | Clear(reply) -> reply.Reply(x) return!loop(List.empty<'a>) } loop(initial)) /// Clears the object pool, returning all of the data that was in the pool. memberthis.ToListAndClear() =agent.PostAndAsyncReply(Clear) /// Puts an item into the pool memberthis.Put(item ) =agent.Post(item) /// Gets an item from the pool or if there are none present use the generator memberthis.Get(item) =agent.PostAndAsyncReply(Get)
    • 10.  F# open source project - FractureIO  High performance networking  Composable pipeline library  Agent based infrastructure