-
Notifications
You must be signed in to change notification settings - Fork 282
/
Copy pathtestimonialsplitter.dib
1881 lines (1354 loc) · 97 KB
/
testimonialsplitter.dib
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
#!meta
{"kernelInfo":{"defaultKernelName":"fsharp","items":[{"aliases":[],"languageName":"fsharp","name":"fsharp"}]}}
#!fsharp
#r "nuget: YamlDotNet"
#r "nuget: FParsec"
open System.IO
open YamlDotNet.Serialization
open YamlDotNet.Serialization.NamingConventions
// Read the contents of the testimonials file
let testimonialsPath = "./testimonials/indexcopy.md"
let testimonialContent = File.ReadAllText(testimonialsPath)
type Url = {
Label : string
Path : string
}
type Bullet =
| Simple of string
| Url of Url
type Testimonial = {
Id: string
Quote: string
Bullets: string list
Keywords: string
Markdown: string
}
// // Create some example testimonials
// let testimonials = [
// { Author = "Joh Dokler"; Company = Some "COVID-19 Tracker"; Quote = "By using F# and its strong type system, we were able to keep the code base consistent and easily adaptable to this ever-evolving and growing project."; Keywords = ["web"; "visualization"; "fable"] }
// { Author = {Label="Urs Enzler"; Path="[email protected]"}; Company = Some "Calitime AG"; Quote = "F# allow us to keep the code simple even in complicated business cases."; Keywords = ["azure"; "business logic"; "functions"] }
// ]
#!fsharp
let testimonials = [
{
Id="sledilnik-1"
Quote = "By using F# and its strong type system, we were able to keep the code base consistent and easily adaptable to this ever-evolving and growing project."
Bullets = [
"Joh Dokler"
"COVID-19 Tracker"
"[Project website](https://covid-19.sledilnik.org/en/)"
"[Source code](https://github.com/sledilnik/website)"
]
Markdown="Covid-19 Tracker Slovenia is a community-driven open source project that collects, curates and publishes Covid-19 data for Slovenia. It was launched in March 2020 and server up to a million daily users.
We use F#/Fable/Feliz for front-end visualization, and F# has proven to be a very good choice for this fast-moving, decentralized project. The majority of people contributing code have never used a functional programming language or even heard of F#. Nevertheless, most contributors were able to quickly navigate the code and develop their own visualizations with little or no orientation and very few bugs or runtime issues.
By using F# and its strong type system, we were able to keep the code base consistent and easily adaptable to this ever-evolving and growing project. And the excellent Fable and Feliz projects allowed easy and smooth integration into the JavaScript ecosystem.
"
Keywords=""
}
{
Id="calitime"
Quote = "F# allow us to keep the code simple even in complicated business cases."
Bullets = [
"Urs Enzler"
"Calitime AG"
]
Markdown = "TimeRocket is a service for attendance time tracking and absence- and shift-planning provided by Calitime AG.
The system runs on Azure, and we use F# on the ASP.NET backend and Azure Functions to program the business logic.
We like F# because discriminated unions, pattern matching, computation expressions and out-of-the-box equality allow us to keep the code simple even in complicated business cases.
"
Keywords = ""
}
{
Id="oconnors-1"
Quote = "F# was so easy to pick up we went from complete novices to having our code in production in less than a week."
Bullets = [
"Jack Mott"
"O'Connor's Online"
"[Case study](https://www.oconnors.com/)"
]
Markdown = "As an experiment to evaluate functional programming as a production tool we developed a
new multi level caching system for our website in F#. Because F# can use existing C#
libaries so easily we were able to proceed rapidly using popular packages such as
StackExchange.Redis and ProtoBuf-Net. In less than a week we had a flexible caching
system in production, complete with an administration page and performance statistics
tracking.
We also found that it was straightforward to use our new F# module from within our
existing C# code, and that the F# code deployed to and ran as an Azure app service
without any special configuration. Adding F# to the code base was completely painless.
The developers on our team are all intrigued by F# and eager to learn more. As well,
we find that at college recruiting events, prospective students are very excited to hear
that we are using a functional language in production
"
Keywords="web application, caching, redis, legal research,oconnors, azure, asp.net"
}
{
Id="lula"
Quote = "At Criipto, we're using F# to keep our cadence high"
Bullets = [
"**Mikkel Christensen, Criipto**"
"[Criipto](https://www.criipto.com/)"
"[Criipto Verify](https://manage.criipto.id)"
"[permalink](#criipto)"
]
Markdown = "We've found F# to be a highly productive language, and at the same time it let's us create codebases with low cost of maintenance.
We switched from C# to F# around 2015, after working in C# for about 7 years. And even if C# is certainly also productive, it does not get close to what F# brings to the table. While both languages allow for creating systems with very low defect-rates, we find that the effort required in F# is much, much smaller - yet instills more confidence. This is due to the fact that in many cases, we can just lean on the compiler, instead of having to resort to writing scores of unit tests.
The type system really makes all the difference when dealing with a complex domain. It is also a very strong ally when integrating 3rd-party systems into a multi-tenant public cloud offering: It enables us to encode very heterogenous external components directly in strong types.
And to top it all up, working in F# is very enjoyable - the terseness and the expressiveness of the language provide a more distraction-free experience than other languages we have worked with. As an aside, we'll note that we have been quite surprised by how addictive compile-time errors can be. Even if they are annoying at the outset, once one realizes how they can be used as a very effective substitute for quite a lot of boilerplate unit tests, they really end up being a very important (and constructive) part of a daily workflow.
"
Keywords = "identity and access, idaaaas, kyc, e-ID, lean scale-up"
}
{
Id="compositional-it"
Quote = "On a release of a complex rules engine and data transformation system to one of our customers, we were delighted to hear that across 90+ markets, not one of them found any issues with any of the calculations in the datasets. F# just works."
Bullets = [
"**Isaac Abraham, Compositional IT**"
"[Compositional IT](http://compositional-it.com/)"
]
Markdown = "As a consultancy geared towards delivering solutions to customers in a variety of sectors, we rely on F# for all of our solutions, whether it's a rules engine, a distributed and scalable data transformation system on Azure or a customer-facing web application. I love the fact that we have confidence in our deliverables thanks in no small part to the pit of success that F# leads us down; we very, very rarely encounted bugs that we saw time and again with other languages and frameworks. At the same time, we're able to consistently deliver to our customers much more quickly than we might have done otherwise - a key value proposition for many of our customers who often need a short time to market."
Keywords="azure, consultancy, functional programming, time to market, startup"
}
{
Id="cleartax"
Quote = "At ClearTax, We have built a whole product from the ground-up in F#. It's been running in production for a couple of years — this has been a great experience for us."
Bullets = [
"**Ankit Solanki, [ClearTax](https://cleartax.in)**"
"[ClearTax](https://www.youtube.com/watch?v=BYRpZ7qEMi0)"
]
Markdown="The expressiveness and power of F# has resulted in shorter build cycles, simpler business logic (with fewer bugs!) and the ability to quickly evolve the product.
Type Providers have let us add support for a lot of data formats (Government formats, Excel files, third party sources) very quickly. Pattern matching has made it possible to simplify complex business logic. F# has been a joy to work with, and we're using it more and more throughout our products now.
"
Keywords="startup, finance, taxation, type providers, functional programming"
}
{
Id="deyan-petrov"
Quote = "F# brought correct defaults, simplicity and safety back to our coding"
Bullets = [
"**Deyan Petrov, [5G Pay](https://5gpay.com/)**"
"[permalink](#deyan-petrov)"
]
Markdown="""A couple of years ago we started a greenfield project with backend (microservices) 100% written in F#. The language allowed/allows us to deliver a lot with a very small team, resulting in a concise and easily maintainable codebase.
We are solely focusing on the basics - functions and records, and shying away from OOP or any other complicated constructs. Among the "exotic" features of F# we use are only a few [computational expressions](https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/computation-expressions) - Async, AsyncResult, Result, as well as the [units of measures](https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/units-of-measure) for strongly-typing GUIDs and other domain attributes. Even Dependency Injections we with straightforward [partial application](https://fsharpforfunandprofit.com/posts/partial-application/) unstead of using the sophisticated Reader monad or similar.
Being a member of the .NET family F# still gives us access to .NET BCL and any (performance) improvements of it, as well as to all 3rd-party libraries written in C# (e.g. Azure SDKs, sftp, email clients and many others).
Onboarding of new team members (usually with C# background) has been pretty easy and quick.
"""
Keywords="simple, safe"
}
{
Id="lula"
Quote="The sensible defaults (immutability, non-nullability, algebraic data types, etc.) along with the power of the F# compiler enables our team to quickly and concisely develop systems."
Bullets = [
"**Matt McCarty**"
"Staff Software Engineer"
"[Lula](https://www.lula.is/)"
"[permalink](#lula)"
]
Markdown = "At Lula, we have found F# to be an excellent choice for building domain-driven APIs to service the insurance industry. The sensible defaults (immutability, non-nullability, algebraic data types, etc.) along with the power of the F# compiler enables our team to quickly and concisely develop systems. The developer experience and tooling is top-tier and the ecosystem is rich and vast, thanks to F# targeting the .NET platform. In addition, the nature of the type system moves an entire class of errors from being runtime errors to compile-time errors.
I would recommend any software engineer that cares about their craft to take the time and learn F#...not only will it make you a better developer, you will have some fun along the way!
"
Keywords="API, domain modeling, insurance"
}
{
Id="insurello"
Quote = "The compiler and the use of exhaustive pattern matching have saved us from what could’ve been many mistakes in production."
Bullets = [
"**Kristian Lundström & Simon Lydell**"
"Software Engineers"
"[Insurello](https://www.insurello.se/)"
"[permalink](#insurello)"
"[source](https://github.com/fsharp/fsharp.org/pull/918)"
]
Markdown="At Insurello, F# lets us model complicated business data with a lightweight syntax in a way that feels closer to reality. The type system helps us avoid creating impossible states and enables us to focus on the business problems. The compiler and the use of exhaustive pattern matching have saved us from what could’ve been many mistakes in production. F# is “just the right amount of FP” which helps us write simple and maintainable code and makes it easy to onboard people, even those with no background in Functional Programming."
Keywords="domain modeling, type system, maintainability, insurtech, claims management"
}
{
Id="kaggle-1"
Quote = "The F# code is consistently shorter, easier to read, easier to refactor and contains far fewer bugs. As our data analysis tools have developed ... we've become more productive."
Bullets = [
"**Kaggle**"
"[permalink](#kaggle-1)"
]
Markdown = "At Kaggle we initially chose F# for our core data analysis algorithms because of its expressiveness.
We've been so happy with the choice that we've found ourselves moving more and more of
our application out of C# and into F#. The F# code is consistently shorter, easier to read,
easier to refactor, and, because of the strong typing, contains far fewer bugs.
As our data analysis tools have developed, we've seen domain-specific constructs
emerge very naturally; as our codebase gets larger, we become more productive.
The fact that F# targets the CLR was also critical - even though we have a large existing
code base in C#, getting started with F# was an easy decision because
we knew we could use new modules right away."
Keywords="data science, machine learning, startup"
}
{
Id="simon-cousins-1"
Quote = "The use of F# demonstrates a sweet spot for the language within enterprise software"
Bullets = [
"**Simon Cousins**"
"[permalink](#simon-cousins-1)"
]
Markdown = "I have written an application to balance the national power generation schedule for a portfolio
of power stations to a trading position for an energy company. The client and server components
were in C# but the calculation engine was written in F#.
The use of F# to address the complexity at the heart of this application clearly demonstrates
a sweet spot for the language within enterprise software, namely algorithmically complex
analysis of large data sets. My experience has been a very positive one.
"
Keywords="energy, trading, calculations, ETL, extract, transform, load"
}
{
Id="credit-suisse-abstract"
Quote = "At Credit Suisse, we've been using F# to develop quantitative models for financial products"
Bullets = [
"**Howard Mansell**"
"Credit Suisse (at time of writing)"
"[source: CUFP Workshop, 2008](http://cufp.org/archive/2008/abstracts.html#MansellHoward), [permalink](#credit-suisse-abstract)"
]
Markdown = "Building valuation models for derivative trades requires rapid development of mathematical models, made possible by
composition of lower-level model components. We have found that F#, with the associated toolset, provides a
unique combination of features that make it very well suited to this kind of development. In this talk, I will explain how we
are using F# and show why it is a good match. I will also talk about the problems we have had,
and outline future enhancements that would benefit this kind of work.
The abstract to [a talk at the Commercial Users of Functional Programming workshop](http://cufp.org/archive/2008/abstracts.html#MansellHoward)
"
Keywords="financial services, analysis, fixed income, derivatives, financial modelling"
}
{
Id="handelsbanken-1"
Quote = "The performance is phenomenal. We can now re-calculate the entire bank portfolio from scratch in less than a second and the response-time for single deal verification calculation is far below 100 milliseconds."
Bullets = [
"**Jan Erik Ekelof**, M.Sc."
"Head IT-architect and lead developer Counterparty Risk"
"Handelsbanken "
"[permalink](#handelsbanken-1)"
]
Markdown="I first evaluated F# back in 2006 - 2007 for the purpose of math oriented high performance applications within
Financial Risk. I got in spring 2009 a mission to implement a new Real-time Counter-party Risk system covering
all possible present and future deal types within the entire bank. The effort was started with only three
resources, me as architect and lead developer and two colleagues – one risk expert and one high performing
developer. Our first intention was to use C#, but I did a quick proof-of-concept with F# implementing a low
level TCP/IP-communication to an existing risk-system. This showed us and our management that F# could give
us a real productivity boost due to its support for multiple paradigms and functional concepts together with
an impressive support for multi-threading.
Our first delivery is approaching rapidly and F# has proved itself as a real life-saver. We started off using
C# in many places but have since then moved almost entirely into F# due to its ability to reduce the amount of
code required and its simplicity when developing massive parallel computations. The performance is phenomenal.
We can now re-calculate the entire bank portfolio from scratch in less than a second and the response-time for
single deal verification calculation is far below 100 milliseconds(the original demand was 200 milliseconds to
make the application usable for electronic markets). Although some gains are to be attributed to how we have built
our calculation models, F# made it possible for us to implement our algorithms and techniques with very little code
and with a huge similarity to the original mathematical models and regulations (which is important for verification
of correctness). We have also been able to use the support for Async-workflows producing code that is simple and
clear and easy to understand but still runs in parallel when required.
The present application contains 35 to 40.000 lines of F#-code and an equal amount of C#-code. However, our
estimate is that the F# code contains at least 80% of the functionality (which is pretty amazing!). Our experience
shows us that the number of code lines shrinks with a ratio of 1/2 to 1/4 by just porting functionality from
C# to F# (not counting single character or empty lines in the C#-code). We have by remodeling increased the
ratio to the area of 1/5 to 1/8, where the remodeling involves replacing object oriented constructs with
functional ones (and actually removing mutable states). One example from last week was a limit-utilization
module written in F# but using an object-oriented approach containing +300 lines of code. I rewrote it to
below 70 lines of code just by shifting paradigm (and the rewrite made it much easier to understand and verify)!
"
Keywords="financial services, analysis, counterparty risk, fixed income, derivatives, financial modelling"
}
{
Id="bayard-rock-1"
Quote = "The benefits of functional programming in F# have given us a great advantage over our slow moving competitors. "
Bullets = [
"Bayard Rock"
"[permalink](#bayard-rock-1)"
]
Markdown = "At Bayard Rock we work hard every day in the pursuit of new approaches towards anti-money-laundering. Before adopting F# there were often months of turnaround time between development of an idea and actually testing it on real data in our production environment. F#’s succinctness and composability allows us to rapidly iterate on ideas while the type system acts as a safety net. On top of this, it has the advantage of being a first class member of the .NET ecosystem and so integrates seamlessly with our Microsoft stack systems. This means that instead of months we can often see our ideas come to life in just days.
The benefits of functional programming in F# have given us a great advantage over our slow moving competitors. After three years of using F# our products have consistently gotten significantly better each year without sacrificing stability. Our clients often are amazed by how we can quickly adapt to unique challenges and how we can find the bad guys hiding in their data much more effectively than anyone else. Little do they know that it’s largely thanks to our secret weapon, F#.
"
Keywords="financial services, analysis, anti-money-laundering, counterparty risk, machine-learning"
}
{
Id="grange-insurance-1"
Quote = "Grange Insurance parallelized its rating engine to take better advantage of multicore server hardware"
Bullets = [
"**Grange Insurance**"
"[permalink](#grange-insurance-1)"
]
Markdown = "For nearly 75 years, Grange Insurance has offered competitive products and services to policyholders
in more than a dozen U.S. states. To maintain its well-earned reputation and standing, the company decided to
enhance its rating engine—a software tool for rating policies and performing what-if modeling, impact analyses,
and other vital activities. Working with the Sophic Group and using the Microsoft Visual Studio Team System development
environment and F# programming language, Grange Insurance parallelized its rating engine to take
better advantage of multicore server hardware, and in so doing garnered significant performance benefits.
Processes that used to require hours now take just minutes, enabling the company to trim time-to-market
by weeks and making it far easier for independent agents to sell and service Grange products.
"
Keywords="insurance, parallelization, financial services"
}
{
Id="aviva-flying-frog-1"
Quote = "Large insurance company developed an entire pension quote calculator entirely in F# in under 100 days with no prior F# experience at all..."
Bullets = [
"**Large insurance company**"
"[source 1](http://stackoverflow.com/questions/952318/what-are-the-benefits-of-using-c-sharp-vs-f-or-f-vs-c), [source 2](http://www.quora.com/Which-organizations-use-the-F-programming-language-in-a-non-trivial-fashion/answer/Jon-Harrop-1), [permalink](#aviva-flying-frog-1)"
]
Markdown = "One of the world's largest insurance companies have F# code in production, are starting several
more projects in F#. We are currently consulting for this company (£2.5bn profit) who have migrated
some of their number crunching and business logic to F# and are so happy with the results
(10x faster and 10x less code vs their Visual C++ 6) that they are proposing to migrate 1,600,000 lines of code to
F#. In particular, their developers found F# easy to learn and use.
... my predecessor developed an entire pension quote calculator (typically scheduled to take 300-400 man days)
entirely in F# in under 100 days with no prior F# experience at all. Performance is 10×
better than the C++ that it replaces because the new code avoids unnecessary copying and exploits multicore
parallelism. Part of my job here will be to give basic F# training to around 20 people and bring a few people up to expert level.
In answer to \"Can you give any evidence for 10x performance gain over C++?\". The insurer's C++
code is a simple manual translation from very inefficient Mathematica code that suffers from several pathological
performance problems mainly centered around excessive copying. The F# rewrite does not have these problem.
The 10x performance gain was verified by the client.
"
Keywords="financial services, insurance, actuarial"
}
{
Id="yan-cui"
Quote = "The F# solution offers us an order of magnitude increase in productivty..."
Bullets = [
"**GameSys**"
"Yan Cui"
"Lead Server Engineer"
"[source](http://www.dotnetrocks.com/default.aspx?showNum=846), [permalink](#yan-cui)"
]
Markdown = "F# is becoming an increasingly important part of our server side infrastructure that supports
our mobile and web-based social games with millions of active users. F# first came to prominence
in our technology stack in the implementation of the rules engine for our social slots games
which by now serve over **700,000 unique players** and **150,000,000 requests** per day at peaks
of several thousand requests per second.
The F# solution offers us an **order of magnitude increase in productivity** and allows
one developer to perform the work that are performed by a team of dedicated developers on an
existing Java-based solution, and is critical in supporting our agile approach and bi-weekly
release cycles.
The [agent-based programming model](http://www.developerfusion.com/article/139804/an-introduction-to-f-agents/)
offered by F#'s MailboxProcessor allows us to **build thread-safe components with high-concurrency requirements effortlessly**, without using locks and sacrificing maintainability and complexity.
These agent-based solutions also offer much improved efficiency and latency whilst running at scale.
Indeed our agent-based stateful server for our [MMORPG](https://apps.facebook.com/herebemonsters/)
has proved a big success and great cost saver that we're in the process of rolling it out across
all of our social games!
"
Keywords="gaming, agents, cloud, big data, scalability"
}
{
Id="james-moore"
Quote = "Using F# for cross-platform mobile development (Android, iOS) saves development time"
Bullets = [
"James Moore"
"Senior Software Developer"
"Digium, Inc"
"[permalink](#james-moore)"
]
Markdown = "We wanted to develop our Android and iOS applications using as much shared code as possible.
We built a reactive architecture using F# actors (aka mailbox processors) to build a very robust
multithreaded system that was easily portable between Android and iOS.
Our F# actors (shared across iOS and Android) expose .Net IObservables that are consumed by UI systems written for the native platforms.
Dividing the system in that way allowed for testable multithreaded code that would have been difficult to write in other .Net languages.
"
Keywords="iOS,Android,Xamarin,reactive"
}
{
Id="simard-1"
Quote = "For a machine learning scientist, speed of experimentation is the critical factor to optimize. "
Bullets = [
"**Patrice Simard**"
"Distinguished Engineer"
"Microsoft "
"[permalink](#simard-1)"
]
Markdown = "I wrote the first prototype of the click prediction system deployed in Microsoft AdCenter in F# in a few days.
For a machine learning scientist, speed of experimentation is the critical factor to optimize. Compiling is
fast but loading large amounts of data in memory takes a long time. With F#’s REPL, you only need to load the
data once and you can then code and explore in the interactive environment. Unlike C# and C++, F# was designed
for this mode of interaction. It has the ease of use of Matlab or Python, both of which I have used extensively
in the past. One problem with Matlab and Python is that they are not strongly typed. No compile-time type
checking hurts speed of experimentation because of bugs, lack of reusability, high cost of refactoring, no
intellisense, and slow execution. Switching to F# was liberating and exhilarating. 2 caveats: Not every
problem fits that model. With a bit of discipline, such as avoiding massive parallelism for as long as
possible, the model goes a long way. The second caveat is that the cost of learning F# is steep. For me, it
was 2 weeks of decreased productivity. It has proven a worthwhile investment.
As a machine learning practitioner programming in F#, I constantly switch between two activities:
1) writing prototype code (highly interactive ugly code with throw away results, functions, and visualizations)
and 2) upgrading prototype code to library standard (fast, generic, reusable). When I go back to writing
prototypes, I build on top of the newly upgraded functions. In F#, the cost of switching between these two
modes is minimal: often nothing needs to be done other than adding comments and deleting deprecated functions.
This means that most of the time is dedicated to experimenting and the majority of the code is close to shipping
quality. Some people can do this in C# or Matlab, but I find that F# excels at it.
I started F# with deep suspicions regarding efficiency. My first test was to link F# with C++/CLI and
check performance of calling SSE/AVX optimized code. As hoped, F# is comparable to C# when it comes to
speed. You have the same flexibility to link with well optimized code. The inline generics are truly
magical: same IL in the linked DLLs, but the functions expand to specialized fast code when you instantiate
them. Compromises between intuitive code and efficient code still need to be made. I found that “for” loop,
“tail recursive” loop, or Parallel.For with ThreadLocal loops, are faster than a succession of piped IEnumerables
(seq in F#). F# does not hamper one’s ability to write ugly fast code. Rest assured.
Several people in the machine learning group in Microsoft Research have switched to F# for the reasons
above. The world is slowly moving toward functional programming with good justifications: the code is
cleaner and easier to debug in a distributed environment. Among the available functional languages, F#
is a compelling option.
"
Keywords="advertising, machine learning, data science, statistics, predication"
}
{
Id="goswin-1"
Quote = "We see great potential for F# to be used as a scripting language in CAD; it fits very well for computational design challenges in the construction industry."
Bullets = [
"**Goswin Rothenthal**"
"Design Engineer"
"Waagner Biro"
"[permalink](#goswin-1)"
]
Markdown = """<a href="http://www.waagner-biro.com/en/company/news-press/news/oriental-jewel-by-waagner-biro-the-domed-roof-of-the-louvre-abu-dhabi"> <img src="/img/big/goswin-waggner.png" /></a>
In recent years many Architects have discovered that they can greatly enlarge their design repertoire by the use of parametric design, programming or scripting. Architects can now quickly and easily explore new geometries previously unseen in Architecture. Besides being designed in a novel way these geometries can also be exactly represented and reasoned about in terms of structural feasibility and manufacturing constraints. These facts take new geometries out of the dreams of Architects and make them real candidates for construction.
One such project is the *Louvre Abu Dhabi* by Jean Nouvel. Waagner-Biro was awarded the construction contract for the Dome. For the cladding of this dome more than 450´000 individual cutting and drilling patterns of custom aluminium extrusions had to be described and automated. The sheer scale and complexity of the cladding on the dome required us to re-evaluate our parametric design approach. I developed an F# application to represent and organize all cladding elements of the dome. It includes a small geometry kernel and an adapted version of the Half Edge Data Structure to efficiently query the neighbourhood of each element. I used Rhino and its .NET API to host the F# DLL for drawing and visualisation. This application enabled us to have an integrated workflow from the main geometry setout all the way down to the manufacturing data in a single parametric model. This project was the first use of F# at Waagner-Biro for a large scale project. The switch to F# from dynamic scripting languages helped to reduce development time and execution time. The strongly typed environment, algebraic data types and immutable data helped to avoid a whole range of bugs and fits well the domain of generating static 3d geometry. I see great potential for F# to be used as scripting languages in CAD, especially since most big CAD packages already offer a .NET API.
(Image credits: Jean Nouvel Architects)
"""
Keywords="geometry, CAD, construction industry, Rhino"
}
{
Id="lemball-1"
Quote = "The results speak for themselves."
Bullets = [
"**Matt Ball**"
"Liz Earle Beauty Co. Ltd"
"[permalink](#lemball-1)"
]
Markdown = """As a business we actively seek improvement every single day. This is the same for our IT systems,
so we have been searching for a means to do that in our in-house software systems.
The F# type system has allowed us to do this - by eliminating null references, increasing type
safety and creating rich domain models that help us express hard-and-fast business rules in a
way that we can really lean on the compiler; while actually reducing our total lines of code
(and noise!). Doing so has reduced both our requirement for expensive bug hunts in our
production systems, and the overall cost of maintaining unnecessary code complexity.
We have been evaluating F# for a year now, and have components in our production systems that
have been bug-free since deployment. The results speak for themselves.
"""
Keywords="retail, e-commerce, ETL, web services, soa, correctness"
}
{
Id="emea"
Quote = "...we have decided to use F# as our functional language to have automatic integration with rest of the system..."
Bullets = [
"EMEA-based Security Solutions Company"
"[permalink](#emea)"
]
Markdown = """We develop security product to protect critical infrastructure (e.g. Oil Refinery, Airport, etc) for countries across
the globe.... In core of our product there are prediction algorithms. We use different modeling and theorems
(Monte Carlo, Action, etc) to implement the prediction components. ... Since we are rewriting our next generation product
using .NET, we have decided to use F# as functional language to have automatic integration with rest of the system. ... We
also have advanced machine learning components (Artificial Intelligence) and functional languages are the
best fit to write AI stuff. We are planning to use F# as the primary programming language in this
area because of its interoperability with .NET. """
Keywords="security, integration"
}
{
Id="financial-services-1"
Quote = "With its new tools, the bank can speed development by 50 percent or more, improve quality, and reduce costs."
Bullets = [
"**Large Financial Services Firm, Europe**"
"[source](http://www.microsoft.com/casestudies/Case_Study_Detail.aspx?casestudyid=4000006794), [permalink](#financial-services-1)"
]
Markdown = """A large financial services firm in Europe sought new development tools that could cut costs, boost productivity,
and improve the quality of its mathematical models. To address its needs, the bank deployed F#, the
.NET Framework, and Visual Studio. It will soon upgrade to Visual Studio 2010 and then integrated
F#. With its new tools, the bank can speed development by 50 percent or more, improve quality, and reduce costs."""
Keywords="financial services, financial modelling, derivatives, fixed income"
}
{
Id="boston-based-company"
Quote = "F# encourages Reason Driven Development that leads to virtually bug-free code"
Bullets = [
"**Boston-based Financial Services Firm, Fixed Income**"
"[permalink](#boston-based-company)"
]
Markdown = """We are using F# because it considerably increases speed of software development which is crucial
for a small company with limited development resources. The most enjoyable feature of this language
is that the developer can reason about the code instead of relying only on unit tests.
I would say the language encourages Reason Driven Development methodology which leads to
virtually bug-free code. F# as strongly typed functional language ideally fits for tasks our
software solves – Fixed Income securities trading optimization. It is also very important that
F# computation engine could be seamlessly integrated with other parts of .NET-based software product.
"""
Keywords="fixed income, trading, optimization, financial services"
}
{
Id="early-warning-1"
Quote = "At a major Investment Bank, we used F# to build an Early Warning Indicator System for Liquidity Risk"
Bullets = [
"**Stephen Channell**"
"Cepheis Ltd "
"[permalink](#early-warning-1)"
]
Markdown = """Early Warning Indicators is a standalone dashboard application to monitor real-time market
movements and highlight potential risk for further analysis. EWI subscribed to real-time equity,
Forex and commodity prices and needed to calculate Red/Amber/Green status in real-time for
tolerance breaches and to generate dashboard reports as needed.
The business wanted the flexibility to define formulas using Excel expressions, but spreadsheet
components could not cope with the data-rate without conflation and management didn’t want a
solution that relied on an Excel template and IT change control to add new indicators.
F# was chosen for development productivity, performance of a cell framework implemented using
computation expressions; ease with which Excel expressions could be parsed as a DSL and .NET
integration with QALib, Market and timer-series data.
Post implementation review highlighted that (given resource and time constraints) functionality
would have been sacrificed without F# and its associated tooling.
"""
Keywords = ""
}
{
Id="london-based-company"
Quote = " I keep being surprised by how compact and readable F# is..."
Bullets = [
"**London-Based Asset Management Company**"
"[permalink](#london-based-company)"
]
Markdown = """We have set up a complete risk management system that combines several data sources, presents them in a ...
WPF user interface, and does a LOT of calculation behind the scenes. When the calculation
requires a proper algorithm (i.e. anything that is more complex than a simple for loop),
our choice has been F#. I have to say I keep being surprised by how compact it is and, nonetheless,
how readable it is even when I'm reading code that I hadn't looked at or thought about for six months.
"""
Keywords="data, analysis, calculation, financial services, derivatives"
}
{
Id="cme-1"
Quote = "The efficient use of functional programming throughout the R&D cycle helped make the cycle faster and more efficient."
Bullets = [
"Moody Hadi (CME Group)"
"[permalink](#cme-1)"
]
Markdown = """The credit markets have varying pockets of liquidity. Market participants would like to understand how the
liquidity of their set of entities changes relative to the overall market. A liquidity scoring model is
needed to provide these metrics across the entire CDS universe. Functional programming and specifically
F# was used in order to provide the market with a fast and accurate solution. ... The research and development cycle was made faster and more efficient by the effective use of
functional programming.
The efficient use of functional programming throughout the R&D cycle helped make the cycle faster and more efficient.
Less time was spent on translating requirements, miscommunications etc and more on producing a fast and accurate solution quickly.
Since programmers can understand your quant code they can focus on their core competency – developing fast and reliable production code.
The development exercise becomes catered towards optimization, performance tuning and error handling (i.e. making the code reliable)
Functionality is not lost from the prototype due to miscommunication or rather crude documentation/requirements, which saves time in testing.
Mass regression testing is easy with precise precision level differences between the prototype and the production system.
"""
Keywords="imperative, functional, financial services, portfolio analysis"
}
{
Id="simon-cousins-2"
Quote = "I have now delivered three business critical projects written in F#. I am still waiting for the first bug to come in."
Bullets = [
"**UK-based Power Company**"
"Simon Cousins"
"[permalink](#simon-cousins-2)"
]
Markdown = """I am both a C# dev and an F# dev. I can only offer subjective anecdotal evidence based
on my experience of delivering projects in both languages (I am too busy delivering
software to do anything else).
That said, the one stat in the summary that I find most compelling is the defect rate.
I have now delivered three business critical projects written in F#. I am still waiting
for the first bug to come in. This is not the case with the C# projects I have delivered.
I will continue to monitor and report on this. It might be that I am just on a lucky streak,
but I suspect that the clarity and concision of F# code contributes greatly to its correctness.
"""
Keywords="energy, extract, transform, load, ETL"
}
{
Id="waisal-1"
Quote = "F# proved ideal for the complex data machinations required to build the models from raw Excel input."
Bullets = [
"A Fortune 100 Manufacturer"
"Supplied to FSSF, [permalink](#waisal-1)"
]
Markdown = """We developed a ClickOnce F# / WPF application that scores and ranks thousands of models of part-supplier combinations using Microsoft Solver Foundation (MSF). Agents can chose from the highest scoring combinations to optimize purchasing decisions. F# proved ideal for the complex data machinations required to build the models from raw Excel input. Also, the MSF supplied F# functional wrapper is a great way of using Solver Foundation from F#."""
Keywords="manufacturing, optimization, Excel, solver"
}
{
Id="jon-canning"
Quote = "Type providers made working with external data sources simple and intuitive."
Bullets = [
"**Jon Canning**"
"Property To Renovate"
"[permalink](#jon-canning)"
]
Markdown = """Every day we analyze data for hundreds of thousand of properties, sourced from XML and JSON feeds. Features such as Options and Type Providers have given us incredibly concise, expressive, and testable code with which to handle them, freeing us to focus on business value.
As a developer moving from C#, some of the concepts you read about functional programming can be difficult to grasp and the barrier to entry appears high. However, with just a basic understanding and a helpful and welcoming community, F# has proven to be very productive and has quickly become my language of choice.
"""
Keywords = ""
}
{
Id="advertisement-rating-and-ranking-at-microsoft"
Quote = " Around 95% of the code in these projects has been developed in F#"
Bullets = [
"Anton Schwaighofer, **Microsoft**"
"bing Ads Ranking Allocation and Pricing"
"[source](http://research.microsoft.com/en-us/events/2012summerschool/kenjifsharpfphdsummerschool2012new.pdf), [permalink](#advertisement-rating-and-ranking-at-microsoft)"
]
Markdown = """Around 95% of the code in these projects has been developed in F#. F# allowed for rapid development
of prototypes, and thus also rapid verification or falsification of the underlying mathematical models.
Complex algorithms, for example to compute Nash equilibria in game theory, can be expressed
succinctly. Units of measure reduced the chance of errors dramatically:
Prices, probabilities, derivatives, etc. can already be kept apart at compile time.
"""
Keywords="advertising, ranking, rating, machine learning, statistics"
}
{
Id="microsoft-quantum-1"
Quote = "F# is central to Microsoft’s quantum algorithm research"
Bullets = [
"**Dave Wecker**"
"Microsoft Advanced Strategies and Research"
"[permalink](#microsoft-quantum-1)"
]
Markdown = """F# is central to Microsoft’s quantum algorithm research. The LIQUi|⟩ simulator (Language
Integrated Quantum Operations) presents an extension of F# that presents a
seamless integration of classical and quantum operations. The scale and efficiency
of the simulator allows it to handle among the largest entangled
systems of qubits (quantum bits) ever modeled utilizing a targeted linear algebra package
written entirely in F#. In addition, the modular architecture allows users to
easily extend the system in any desired research direction. The base library is
well over 20,000 lines of code and implements a wide range of modules including
circuits, molecular modeling, spin-glass systems, quantum error correction, machine
learning, factoring and many others. The system runs in client, server and cloud
environments. It is also designed to be used as an educational tool and we have
found that bringing new users up to speed is a quick and painless process."""
Keywords="simulation, quantum, Microsoft, modelling"
}
{
Id="byron-cook-1"
Quote = "F# is the night vision goggles I need when I go into the dark and attempt to solve previously unsolved problems. "
Bullets = [
"**Professor Byron Cook**"
"Microsoft, [permalink](#byron-cook-1)"
]
Markdown="""I’m one of the first users of F#, since 2004. In my work (e.g. SLAM, Terminator, Zapato, T2, etc)
I find that F# is the night vision goggles I need when I go into the dark and attempt to solve
previously unsolved problems. Everything becomes simple and clear when expressed in F#.
"""
Keywords="verification, algorithms, analysis, problem solving"
}
{
Id="andrew-phillips-1"
Quote = "F# will continue to be our language of choice for scientific computing."
Bullets = [
"**Dr. Andrew Phillips**"
"Head of Bio Computation Group"
"Microsoft Research, [permalink](#andrew-phillips-1)"
]
Markdown="""I lead the Biological Computation group at Microsoft Research, where we are developing methods and
software for [modelling and analysis of biological systems](http://research.microsoft.com/biology).
We have been using F# in our group for the past 7 years, and it's the language of choice for all
of our software development. In particular it forms the basis of our software for programming
[computational circuits made of DNA](http://research.microsoft.com/dna), for programming
[genetic devices that operate inside cells](http://research.microsoft.com/gec), and for programming
[complex biological processes in a modular way](http://research.microsoft.com/spim).
The functional data structures and static type-checking that F# provides are ideally suited for developing
these domain-specific languages, and the Visual Studio integration is superb for debugging
and source control. The integration with .Net is seamless, and allows us to incorporate
efficient numerical and visualisation libraries written in C#. It also allows us to
take advantage of the full suite of .Net UI components.
Our languages are specified with a formal syntax and semantics, which are rigorously
analysed prior to their implementation. Programming in a functional language like F# brings the implementation much closer to the
formal specification, which is important for ensuring accurate simulation and
probabilistic analysis. Correct implementation of the semantics is critical, since even
small coding errors can give rise to divergent predictions, which can in turn compromise
biological experiments. F# is a great language for writing clean, concise code, which is
statically typed within a professional development environment that supports a wealth of
libraries. It will continue to be our language of choice for scientific computing.
"""
Keywords="biology, modelling, algorithms, analysis, DNA computing, correct, scientific computing"
}
{
Id="miccrosoft-engineering-1"
Quote = "In our engineering group at Microsoft we use F# for several projects"
Bullets = [
"Microsoft Engineering Team"
"[permalink](#microsoft-engineering-1)"
]
Markdown="""In our internal engineering group at Microsoft, F# is used for several important tools:
* analyzing feedback on the web to look for compatibility-related issues,
* a static code analyzer to detect compatibility regressions in a product,
* a delta-debugging tool to help root cause regression analysis in product builds.
"""
Keywords="tools, engineering, debugging, builds, static analysis"
}
{
Id="dylan-hutchinson-intern-1"
Quote = "My team chose F# for its functional paradigm, maturity, and ease of interoperation with the .NET framework"
Bullets = [
"**Dylan Hutchison**"
"Microsoft Research (intern), Stevens Institute of Technology"
"[permalink](#dylan-hutchinson-intern-1)"
]
Markdown="""With an idea for a new domain specific language, my team chose F# for its functional paradigm, maturity, and ease of interoperation with the .NET framework. I wrote the language primitives in F#’s arsenal of data types (records, discriminated unions, a couple classes at the top level), implemented operations on the types using its hierarchy of modules, and turned our operations into a working demo in F# Interactive, all in about 10 days.
I jumped for joy each time my code executed correctly on the first pass, and in the few cases it did not, debugging through Visual Studio felt natural and quick. As for .NET, integrating with Microsoft Excel was easy by importing the necessary DLLs, though Excel posed challenges beyond F#’s reach. Finally, I can verify that F# delivers a sense of correctness and safety, stronger than other languages I worked with in the past. It is reassuring to know your code will execute exactly as you intend."""
Keywords="DSL, Excel, machine learning, correctness"
}
{
Id="michael-hansen"
Quote = "The simple, well-designed and powerful core of the language was perfect for introducing the fundamental concepts of functional programming."
Bullets = [
"**Michael R. Hansen**"
"Associate Professor, Technical University of Denmark"
"[permalink](#michael-hansen)"
]
Markdown="""Producing an [F#-based book](http://www2.compute.dtu.dk/~mire/FSharpBook/index.html) on functional programming has been a fantastic experience.
Using this material in an [F#-based course](http://www.compute.dtu.dk/courses/02157)
introducing the fundamental concepts of functional programming has
been a delightful experience as well. The simple,
well-designed, yet powerful, core of the language was perfect for
that purpose and, to our surprise, the transition from using SML
to using F# actually made the tooling easier for students no
matter which platforms they used.
Furthermore, F# with it rich runtime environment has proved to be
an excellent programming platform in research applications and in
a more advanced course aiming at showing the role of functional
programming in a broad variety of applications ranging from
computer science applications to more real-life applications. In
the first version of this course, given together with Anh-Dung Phan,
the students completed three projects in three weeks: One being an
interpreter for a rich imperative programming language,
another being implementation, application and analysis of a
functional pearl, and the last being a curriculum planning system
for studies at the Technical University of Denmark.
"""
Keywords = ""
}
{
Id="hans-rischel"
Quote = "Solving a number of programming problems using the language convinced me of the supreme qualities of F#"
Bullets = [
"**Hans Rischel**"
"Former teacher of computer science at the Technical University of Denmark"
"[permalink](#hans-rischel)"
]
Markdown="""I was approached by my former colleague Michael (Michael R. Hansen) in autumn
2010 where he proposed that we should write a new textbook on functional
programming - now using the F# programming language. To begin with I was quite
sceptical about using a programming language appearing as part of a Microsoft
program package. Solving a number of programming problems using the language
convinced me, however, of the supreme qualities of F# - and we embarked on
the project of getting acquainted with F# and writing the textbook.
Michael and I spent considerable time solving traditional programming
problems in F#. A combination of functional and imperative F# with an
occasional pinch of OO gives a very pleasing platform for program
development - once you have found your way through the wilderness of MSDN
documentation (newcomers to the MSDN world may benefit from the
MSDN library documentation found on the [web-site of the book](http://www2.compute.dtu.dk/~mire/FSharpBook/index.html).
All of Chapter 10 and part of Chapter 11 present program examples using
this programming style.
Computation expressions look esoteric to begin with, but they are actually
rather useful. We spent much time
trying to get this concept down to earth, with the purpose of making it accessible
to simple-minded people like ourselves. The reader may judge how far we
succeeded by studying Chapter 12 of the book.
Writing this textbook with Michael has been an exciting experience.
"""
Keywords = ""
}
{
Id="dsyme-ad-predict-1"
Quote = "F#'s powerful type inference means less typing, more thinking"
Bullets = [
"**Don Syme**"
"Principal Researcher, Microsoft"
"Eclipse Summit Europe 2009, [source](http://www.slideshare.net/lgayowski/taking-functional-programming-into-the-mainstream-eclipse-summit-europe-2009), slide 49"
"[permalink](#dsyme-ad-predict-1)"
]