skip to main content
research-article
Open Access

The early history of F#

Published:12 June 2020Publication History
Skip Abstract Section

Abstract

This paper describes the genesis and early history of the F# programming language. I start with the origins of strongly-typed functional programming (FP) in the 1970s, 80s and 90s. During the same period, Microsoft was founded and grew to dominate the software industry. In 1997, as a response to Java, Microsoft initiated internal projects which eventually became the .NET programming framework and the C# language. From 1997 the worlds of academic functional programming and industry combined at Microsoft Research, Cambridge. The researchers engaged with the company through Project 7, the initial effort to bring multiple languages to .NET, leading to the initiation of .NET Generics in 1998 and F# in 2002. F# was one of several responses by advocates of strongly-typed functional programming to the "object-oriented tidal wave" of the mid-1990s. The development of the core features of F# 1.0 happened from 2004-2007, and I describe the decision-making process that led to the "productization" of F# by Microsoft in 2007-10 and the release of F# 2.0. The origins of F#'s characteristic features are covered: object programming, quotations, statically resolved type parameters, active patterns, computation expressions, async, units-of-measure and type providers. I describe key developments in F# since 2010, including F# 3.0-4.5, and its evolution as an open source, cross-platform language with multiple delivery channels. I conclude by examining some uses of F# and the influence F# has had on other languages so far.

References

  1. Martín Abadi and Luca Cardelli. 1996. A Theory of Objects. Springer. Google ScholarGoogle ScholarCross RefCross Ref
  2. Isaac Abraham. 2020. SAFE Stack. https://web.archive.org/web/20191207093456/https://safe-stack.github.io/Google ScholarGoogle Scholar
  3. Jonathan Allen. 2010. Microsoft’s Experiments with Software Transactional Memory Have Ended. https://web.archive.org/ web/20160414023301/http://www.infoq.com/news/2010/05/STM-DroppedGoogle ScholarGoogle Scholar
  4. David Alsh. 2019. An Update on Go and Generics in 2019. https://web.archive.org/web/20190312110158/https://medium. com/@alshdavid/an-update-on-go-and-generics-in-2019-59efdcc97a42Google ScholarGoogle Scholar
  5. Jim Alves-Foss (Ed.). 1999. Formal Syntax and Semantics of Java. Lecture Notes in Computer Science, Vol. 1523. Springer Berlin Heidelberg. Google ScholarGoogle ScholarCross RefCross Ref
  6. Apple. 2014. Swift introduction. https://www.youtube.com/watch?v=MO7Ta0DvEWA Apple WWDC 2014.Google ScholarGoogle Scholar
  7. Isabelle archives. 1994. Added infix op also. https://web.archive.org/web/20120726024825/http://isabelle.in.tum.de/repos/ isabelle/rev/daca5b594fb3Google ScholarGoogle Scholar
  8. Julian Assange. 2000. Forum Message. https://web.archive.org/web/20200122221804/http://caml.inria.fr/pub/ml-archives/ caml-list/2000/08/6b8b195b3a25876e0789fe3db770db9f.en.htmlGoogle ScholarGoogle Scholar
  9. Desire Athow. 2014. Pentium FDIV: The processor bug that shook the world. https://web.archive.org/web/20181123221019/ https://www.techradar.com/uk/news/computing-components/processors/pentium-fdiv-the-processor-bug-thatshook-the-world-1270773Google ScholarGoogle Scholar
  10. Nick Benton and Andrew Kennedy. 1999. Interlanguage Working Without Tears: Blending SML with Java. In Proceedings of the fourth ACM SIGPLAN International Conference on Functional Programming (ICFP ’99), Paris, France, September 27-29, 1999, Didier Rémy and Peter Lee (Eds.). ACM, 126–137. Google ScholarGoogle ScholarDigital LibraryDigital Library
  11. Nick Benton, Andrew Kennedy, and Claudio V. Russo. 2004. Adventures in interoperability: the SML.NET experience. In Proceedings of the 6th International ACM SIGPLAN Conference on Principles and Practice of Declarative Programming, 24-26 August 2004, Verona, Italy, Eugenio Moggi and David Scott Warren (Eds.). ACM, 215–226. Google ScholarGoogle ScholarDigital LibraryDigital Library
  12. Dave Berry. 2001a. Forum Message. https://web.archive.org/web/20200309165610/https://caml.inria.fr/pub/ml-archives/ caml-list/2001/02/133b91bc1099f414b036a6ded7209d4c.en.htmlGoogle ScholarGoogle Scholar
  13. Dave Berry. 2001b. Forum Message. https://web.archive.org/web/20200309170553/https://caml.inria.fr/pub/ml-archives/ caml-list/2001/02/394c8e018c81d45cda9c71c20d22518b.en.htmlGoogle ScholarGoogle Scholar
  14. Joel Bjornson, Anton Tayanovskyy, and Adam Granicz. 2010. Composing Reactive GUIs in F# Using WebSharper. In Implementation and Application of Functional Languages - 22nd International Symposium, IFL 2010, Alphen aan den Rijn, The Netherlands, September 1-3, 2010, Revised Selected Papers (Lecture Notes in Computer Science), Jurriaan Hage and Marco T. Morazán (Eds.), Vol. 6647. Springer, 203–216. Google ScholarGoogle ScholarCross RefCross Ref
  15. Joel Bjornson, Anton Tayanovskyy, and Adam Granicz. 2011. Composing Reactive GUIs in F# Using WebSharper. In Implementation and Application of Functional Languages, Jurriaan Hage and Marco T. Morazán (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 203–216.Google ScholarGoogle Scholar
  16. Rachel Blasucci. 2016. A History of F#. https://zenodo.org/record/3706701#.Xmjtoaj7RaQGoogle ScholarGoogle Scholar
  17. J. Bloch. 2001. Effective Java: Programming Language Guide. Addison-Wesley. https://books.google.com/books?id= Ra9QAAAAMAAJGoogle ScholarGoogle ScholarDigital LibraryDigital Library
  18. Kurt D. Bollacker, Colin Evans, Praveen Paritosh, Tim Sturge, and Jamie Taylor. 2008. Freebase: a collaboratively created graph database for structuring human knowledge. In Proceedings of the ACM SIGMOD International Conference on Management of Data, SIGMOD 2008, Vancouver, BC, Canada, June 10-12, 2008, Jason Tsong-Li Wang (Ed.). ACM, 1247–1250. Google ScholarGoogle ScholarDigital LibraryDigital Library
  19. Luca Bolognese. 2008. An Introduction to Microsoft F#. https://web.archive.org/web/20190827210341/https://channel9. msdn.com/blogs/pdc2008/tl11Google ScholarGoogle Scholar
  20. Arturo Borquez. 2001. Forum Message. https://web.archive.org/web/20200309170633/https://caml.inria.fr/pub/ml-archives/ caml-list/2001/03/c505a4570bf94080cb8a7f82b2f3598a.en.htmlGoogle ScholarGoogle Scholar
  21. Clint Boulton. 2003. Is F# a Major or Minor Consideration for Microsoft? https://web.archive.org/web/20200310180658/http: //www.internetnews.com/dev-news/article.php/2211931/Is+F+a+Major+or+Minor+Consideration+for+Microsoft.htmGoogle ScholarGoogle Scholar
  22. Gilad Bracha, Martin Odersky, David Stoutamire, and Philip Wadler. 1998. Making the Future Safe for the Past: Adding Genericity to the Java Programming Language. In Proceedings of the 1998 ACM SIGPLAN Conference on Object-Oriented Programming Systems, Languages & Applications (OOPSLA ’98), Vancouver, British Columbia, Canada, October 18-22, 1998, Bjørn N. Freeman-Benson and Craig Chambers (Eds.). ACM, 183–200. Google ScholarGoogle ScholarDigital LibraryDigital Library
  23. Eugene Burmako. 2013. Scala macros: let our powers combine!: on how rich syntax and static types work with metaprogramming. In Proceedings of the 4th Workshop on Scala, SCALA@ECOOP 2013, Montpellier, France, July 2, 2013. ACM, 3:1–3:10. Google ScholarGoogle ScholarDigital LibraryDigital Library
  24. Phillip Carter. 2020. What is F#. https://web.archive.org/web/20190605160132/https://docs.microsoft.com/en-us/dotnet/ fsharp/what-is-fsharpGoogle ScholarGoogle Scholar
  25. Krzysztof Cieślak. 2019. Ionide—A Visual Studio Code package suite for cross platform F# development. https://web. archive.org/web/20191224203325/http://ionide.io/Google ScholarGoogle Scholar
  26. Gavin Clarke. 2010. Microsoft cuts loose Iron languages. https://web.archive.org/web/20191221152303/https://www. theregister.co.uk/2010/10/22/microsoft_kills_dynamic_languages_projects/Google ScholarGoogle Scholar
  27. Simon Cousins. 2016. Does the Language You Use Make a Difference (revisited)? https://web.archive.org/web/ 20160812070612/http://simontylercousins{.NET}/does-the-language-you-use-make-a-difference-revisited/Google ScholarGoogle Scholar
  28. Russ Cox. 2019. The Generic Dilemma. https://web.archive.org/web/20190920172300/https://research.swtch.com/genericGoogle ScholarGoogle Scholar
  29. Miguel de Icaza. 2016. Mono History. https://web.archive.org/web/20191002200140/https://www.mono-project.com/docs/ about-mono/history/Google ScholarGoogle Scholar
  30. J. Duffy. 2008. Concurrent Programming on Windows. Pearson Education. https://books.google.co.jp/books?id=o4ohrd0_yA0CGoogle ScholarGoogle Scholar
  31. Wes Dyer. 2009. A Brief Introduction to the Reactive Extensions for .NET. https://web.archive.org/web/20190120224709/https: //blogs.msdn.microsoft.com/wesdyer/2009/11/18/a-brief-introduction-to-the-reactive-extensions-for-net-rx/Google ScholarGoogle Scholar
  32. Jan Dzik, Nick Palladinos, Konstantinos Rontogiannis, Eirik Tsarpalis, and Nikolaos Vathis. 2013. MBrace: cloud computing with monads. In Proceedings of the Seventh Workshop on Programming Languages and Operating Systems, PLOS 2013, Farmington, Pennsylvania, USA, November 3-6, 2013, Tim Harris and Anil Madhavapeddy (Eds.). ACM, 7:1–7:6. Google ScholarGoogle ScholarDigital LibraryDigital Library
  33. Burak Emir, Martin Odersky, and John Williams. 2007. Matching Objects with Patterns. In ECOOP 2007 - Object-Oriented Programming, 21st European Conference, Berlin, Germany, July 30 - August 3, 2007, Proceedings (Lecture Notes in Computer Science), Erik Ernst (Ed.), Vol. 4609. Springer, 273–298. Google ScholarGoogle ScholarCross RefCross Ref
  34. Martin Erwig. 1996. Active Patterns. In Implementation of Functional Languages, 8th International Workshop, IFL’96, Bad Godesberg, Germany, September 16-18, 1996, Selected Papers (Lecture Notes in Computer Science), Werner E. Kluge (Ed.), Vol. 1268. Springer, 21–40. Google ScholarGoogle ScholarCross RefCross Ref
  35. Mary Jo Foley. 2011. Microsoft drops Dryad; puts its big-data bets on Hadoop. https://web.archive.org/web/20180327103628/ http://www.zdnet.com/article/microsoft-drops-dryad-puts-its-big-data-bets-on-hadoop/Google ScholarGoogle Scholar
  36. Mary Jo Foley. 2014. Microsoft to close Microsoft Research lab in Silicon Valley. https://web.archive.org/web/20170719170224/ http://www.zdnet.com/article/microsoft-to-close-microsoft-research-lab-in-silicon-valley/Google ScholarGoogle Scholar
  37. Steffen Forkmann. 2019. Paket: a dependency manager for .NET. https://web.archive.org/web/20191207100955/https: //fsprojects.github.io/Paket/Google ScholarGoogle Scholar
  38. Steffen Forkmann and Matthias Dittrich. 2019. F# Make: a DSL for Build Tasks and more. https://web.archive.org/web/ 20191106010037/https://fake.build/Google ScholarGoogle Scholar
  39. FSSF Contributors. 2019a. F# Language Design RFCs. https://web.archive.org/web/20190121121629/https://github.com/ fsharp/fslang-design/Google ScholarGoogle Scholar
  40. FSSF Contributors. 2019b. F# Language Suggestions. https://web.archive.org/web/20190121121627/https://github.com/ fsharp/fslang-suggestions/Google ScholarGoogle Scholar
  41. FSSF Contributors. 2020. F# Testimonials. https://web.archive.org/web/20191225110939/https://fsharp.org/testimonials/Google ScholarGoogle Scholar
  42. Jun Furuse. 2002. G’CAML – O’Caml with Extensional Polymorphism Extension. https://web.archive.org/web/ 20151028183010/http://cristal.inria.fr/~furuse/old/generics/index.htmlGoogle ScholarGoogle Scholar
  43. Alfonso García-Caro. 2018. Fable - The compiler that emits JavaScript you can be proud of! https://web.archive.org/web/ 20191230184424/https://fable.io/Google ScholarGoogle Scholar
  44. Jacques Garrigue. 2001. Simple Type Inference for Structural Polymorphism. In The Second Asian Workshop on Programming Languages and Systems, APLAS’01, Korea Advanced Institute of Science and Technology, Daejeon, Korea, December 17-18, 2001, Proceedings. 329–343.Google ScholarGoogle Scholar
  45. Mike Gordon. 2000. From LCF to HOL: A Short History. MIT Press, Cambridge, MA, USA, 169–185.Google ScholarGoogle Scholar
  46. Adam Granicz. 2011. IntelliFactory Your Functional Experts. https://web.archive.org/web/20071102190038/http://www. intellifactory.com:80/Development.aspxGoogle ScholarGoogle Scholar
  47. Adam Granicz. 2020. WebSharper. https://web.archive.org/web/20191221153625/http://websharper.com/Google ScholarGoogle Scholar
  48. Adam Granicz and Loic Denuziere. 2019. Functional, Reactive Web Programming in F#. Springer International Publishing, Cham, 137–160. Google ScholarGoogle ScholarDigital LibraryDigital Library
  49. Philipp Haller and Martin Odersky. 2009. Scala Actors: Unifying thread-based and event-based programming. Theor. Comput. Sci. 410, 2-3 (2009), 202–220. Google ScholarGoogle ScholarDigital LibraryDigital Library
  50. Michael Hansen and Hans Rischel. 2013. Functional Programming Using F#. Cambridge University Press, United Kingdom.Google ScholarGoogle Scholar
  51. Jon Harrop. 2006. F# for Scientists announced by Jon Harrop. https://web.archive.org/web/20190130125113/https: //blogs.msdn.microsoft.com/dsyme/2006/10/23/f-for-scientists-announced-by-jon-harrop/Google ScholarGoogle Scholar
  52. Jon Harrop. 2008. F# for Scientists. Wiley-Interscience, USA.Google ScholarGoogle Scholar
  53. Haskell Contributors. 2017. Why isn’t GHC available for .NET or on the JVM? https://web.archive.org/web/20171003001945/ https://wiki.haskell.org/GHC/FAQGoogle ScholarGoogle Scholar
  54. Haskell Contributors. 2019. List Comprehensions. https://web.archive.org/web/20191218093604/https://wiki.haskell.org/ List_comprehensionGoogle ScholarGoogle Scholar
  55. Haskell Contributors. 2020a. Haskell “do notation”. https://web.archive.org/web/20200225025414/https://en.wikibooks.org/ wiki/Haskell/do_notationGoogle ScholarGoogle Scholar
  56. Haskell Contributors. 2020b. MonadPlus. https://web.archive.org/web/20200110013404/https://wiki.haskell.org/MonadPlusGoogle ScholarGoogle Scholar
  57. Ralf Hinze. 2019. IFIP Working Group 2.8—Functional Programming. https://web.archive.org/web/20190827002406/http: //www.cs.ox.ac.uk/ralf.hinze/WG2.8/Google ScholarGoogle Scholar
  58. Graydon Hoare. 2017. What next? https://web.archive.org/web/20200309171904/https://graydon.livejournal.com/256533. htmlGoogle ScholarGoogle Scholar
  59. Tony Hoare. 2011. Null References: The Billion Dollar Mistake. https://web.archive.org/web/20200226010547/https: //www.infoq.com/presentations/Null-References-The-Billion-Dollar-Mistake-Tony-Hoare/Google ScholarGoogle Scholar
  60. Luke Hoban. 2014. Facilitating Open Contributions for the F# Compiler, Library and Visual F# Tools. https://web.archive.org/web/20190117170952/https://blogs.msdn.microsoft.com/fsharpteam/2014/04/03/facilitatingopen-contributions-for-the-f-compiler-library-and-visual-f-tools/Google ScholarGoogle Scholar
  61. Luke Hoban. 2017. The first TypeScript demo. https://web.archive.org/web/20181112134112/https://hackernoon.com/thefirst-typescript-demo-905ea095a70f?gi=519980eb03eeGoogle ScholarGoogle Scholar
  62. Paul Hudak, John Hughes, Simon Peyton Jones, and Philip Wadler. 2007. A History of Haskell: Being lazy with class. In Proceedings of the 3rd ACM SIGPLAN Conference on History of Programming Languages (HOPL-III. ACM Press, 1–55.Google ScholarGoogle ScholarDigital LibraryDigital Library
  63. Andrew Kennedy. 1995. Programming languages and dimensions. Ph.D. Dissertation. University of Cambridge, UK. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.242978Google ScholarGoogle Scholar
  64. Andrew Kennedy. 2009. Types for Units-of-Measure: Theory and Practice. In Central European Functional Programming School - Third Summer School, CEFP 2009, Budapest, Hungary, May 21-23, 2009 and Komárno, Slovakia, May 25-30, 2009, Revised Selected Lectures (Lecture Notes in Computer Science), Zoltán Horváth, Rinus Plasmeijer, and Viktória Zsók (Eds.), Vol. 6299. Springer, 268–305.Google ScholarGoogle Scholar
  65. Andrew Kennedy and Don Syme. 2001. Design and Implementation of Generics for the .NET Common Language Runtime. In Proceedings of the 2001 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), Snowbird, Utah, USA, June 20-22, 2001, Michael Burke and Mary Lou Soffa (Eds.). ACM, 1–12. Google ScholarGoogle ScholarDigital LibraryDigital Library
  66. J. Launchbury. 1993. Lazy Imperative Programming. In Proceedings of the ACM SIGPLAN Workshop on State in Programming Languages, Copenhagen, DK, SIPL’92. 46–56. http://www.cse.ogi.edu/~jl/Papers/lazyImp.psGoogle ScholarGoogle Scholar
  67. Fabrice le Fessant. 2001. Forum Message. https://web.archive.org/web/20200309170507/https://caml.inria.fr/pub/mlarchives/caml-list/2001/02/b67bc40320ae83c25dd035848a767b19.en.htmlGoogle ScholarGoogle Scholar
  68. Gary T. Leavens. 1995. Foundations of Object-Oriented Languages. ACM SIGPLAN Notices 30 (1995).Google ScholarGoogle Scholar
  69. Xavier Leroy. 2001. Forum Message. https://web.archive.org/web/20150102181325/http://caml.inria.fr/pub/ml-archives/camllist/2001/02/229eebd5314fd127dadb27872f9e4c6f.en.htmlGoogle ScholarGoogle Scholar
  70. Xavier Leroy. 2014. A History of OCaml. https://web.archive.org/web/20140223051451/http://ocaml.org/learn/history.htmlGoogle ScholarGoogle Scholar
  71. David MacQueen. 2015. The History of Standard ML. https://web.archive.org/web/20200224231802/http://sml-family.org/ history/Google ScholarGoogle Scholar
  72. Phillip Carter Mads Torgersen. 2017. Why you should use F#. https://web.archive.org/web/20190910125556/https: //channel9.msdn.com/Events/Build/2017/T6064Google ScholarGoogle Scholar
  73. Conor McBride and Ross Paterson. 2008. Applicative Programming with Effects. Journal of Functional Programming 18 (01 2008), 1–13. Google ScholarGoogle ScholarDigital LibraryDigital Library
  74. Ross McKinlay. 2013. Choose Your Own Adventure Type Provider. https://web.archive.org/web/20170506071823/http: //www.pinksquirrellabs.com/post/2013/07/29/Choose-Your-Own-Adventure-Type-Provider.aspxGoogle ScholarGoogle Scholar
  75. Microsoft. 2019. Language Integrated Query (LINQ). https://web.archive.org/web/20190605160124/https://docs.microsoft. com/en-us/dotnet/csharp/linq/Google ScholarGoogle Scholar
  76. Robin Milner, Mads Tofte, and Robert Harper. 1990. Definition of Standard ML. MIT Press.Google ScholarGoogle ScholarDigital LibraryDigital Library
  77. Gabriela Motroc. [n.d.]. Project Valhalla enters new phase. https://web.archive.org/web/20200309164943/https://jaxenter. com/project-valhalla-enters-new-phase-150570.htmlGoogle ScholarGoogle Scholar
  78. Ross Paterson. 2020. Arrows: A General Interface to Computation. https://web.archive.org/web/20200306225731/https: //www.haskell.org/arrows/syntax.htmlGoogle ScholarGoogle Scholar
  79. Alex Peake and Adam Granicz. 2009. The First Substantial Line of Business Application in F#. In Proceedings of the 2009 Video Workshop on Commercial Users of Functional Programming: Functional Programming As a Means, Not an End (Edinburgh, Scotland) (CUFP ’09). Association for Computing Machinery, New York, NY, USA, Article 6, 1 pages. Google ScholarGoogle ScholarDigital LibraryDigital Library
  80. Tomas Petricek. 2008. Client-side Scripting using Meta-programming. https://web.archive.org/web/20170707011917/http: //tomasp{.NET}/blog/webtools-thesis.aspx/Google ScholarGoogle Scholar
  81. Tomas Petricek, Gustavo Guerra, and Don Syme. 2016. Types from data: making structured data first-class citizens in F#. In Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2016, Santa Barbara, CA, USA, June 13-17, 2016, Chandra Krintz and Emery Berger (Eds.). ACM, 477–490. Google ScholarGoogle ScholarDigital LibraryDigital Library
  82. Tomas Petricek and Don Syme. 2010. Collecting Hollywood’s garbage: avoiding space-leaks in composite events. In Proceedings of the 9th International Symposium on Memory Management, ISMM 2010, Toronto, Ontario, Canada, June 5-6, 2010, Jan Vitek and Doug Lea (Eds.). ACM Press, 53–62. Google ScholarGoogle ScholarDigital LibraryDigital Library
  83. Tomas Petricek and Don Syme. 2011. Joinads: A Retargetable Control-Flow Construct for Reactive, Parallel and Concurrent Programming. In Practical Aspects of Declarative Languages - 13th International Symposium, PADL 2011, Austin, TX, USA, January 24-25, 2011. Proceedings (Lecture Notes in Computer Science), Ricardo Rocha and John Launchbury (Eds.), Vol. 6539. Springer, 205–219. Google ScholarGoogle ScholarCross RefCross Ref
  84. Tomas Petricek and Don Syme. 2014. The F# Computation Expression Zoo. In Practical Aspects of Declarative Languages -16th International Symposium, PADL 2014, San Diego, CA, USA, January 20-21, 2014. Proceedings (Lecture Notes in Computer Science), Matthew Flatt and Hai-Feng Guo (Eds.), Vol. 8324. Springer, 33–48. Google ScholarGoogle ScholarDigital LibraryDigital Library
  85. Simon Peyton Jones, Mark Jones, and Erik Meijer. 1997. Type Classes: An Exploration of the Design Space. In In Haskell Workshop.Google ScholarGoogle Scholar
  86. Simon Peyton Jones and Philip Wadler. 2007. Comprehensive Comprehensions. In Proceedings of the ACM SIGPLAN Workshop on Haskell Workshop (Freiburg, Germany) (Haskell ’07). Association for Computing Machinery, New York, NY, USA, 61–72. Google ScholarGoogle ScholarDigital LibraryDigital Library
  87. Fethi A. Rabhi and Sergei Gorlatch (Eds.). 2003. Patterns and Skeletons for Parallel and Distributed Computing. Springer-Verlag, Berlin, Heidelberg.Google ScholarGoogle Scholar
  88. Sal Restivo. 2004. Mechanizing Proof: Computing, Risk, and Trust, by D. MacKenzie. Cambridge, MA: The MIT Press, 2001. The Information Society 20, 1 (jan 2004), 67–68. Google ScholarGoogle ScholarCross RefCross Ref
  89. Ryan Riley. 2019a. Community for F# Heroes. https://web.archive.org/web/20191225110926/https://c4fsharp{.NET}/#heroesGoogle ScholarGoogle Scholar
  90. Ryan Riley. 2019b. F# User Groups and Meetups. https://web.archive.org/web/20191225110926/http://community.fsharp. org/user_groupsGoogle ScholarGoogle Scholar
  91. D. Sangiorgi and D. Walker. 2001. The Pi-Calculus: A Theory of Mobile Processes. Cambridge University Press. https: //books.google.co.uk/books?id=Se1gQgAACAAJGoogle ScholarGoogle Scholar
  92. Carl-Johan H. Seger, Robert B. Jones, John W. O’Leary, Thomas F. Melham, Mark D. Aagaard, Clark W. Barrett, and Don Syme. 2005. An industrially effective environment for formal hardware verification. IEEE Trans. on CAD of Integrated Circuits and Systems 24, 9 (2005), 1381–1405. Google ScholarGoogle ScholarDigital LibraryDigital Library
  93. S. Somasegar. 2007a. F#—A Functional Programming Language. https://web.archive.org/web/20190117172524/https: //blogs.msdn.microsoft.com/somasegar/2007/10/17/f-a-functional-programming-language/Google ScholarGoogle Scholar
  94. S. Somasegar. 2007b. Private email. 23:34.Google ScholarGoogle Scholar
  95. Bjarne Stroustrup. 2013. The C++ Programming Language (4th ed.). Addison-Wesley Professional.Google ScholarGoogle Scholar
  96. Don Syme. [n.d.]a. The F# September 2008 CTP is now available! https://web.archive.org/web/20190125230131/https: //blogs.msdn.microsoft.com/dsyme/2008/08/29/the-f-september-2008-ctp-is-now-available/Google ScholarGoogle Scholar
  97. Don Syme. [n.d.]b. Programming Languages and .NET, Bill Gates project review. https://web.archive.org/web/ 20200309163401/https://raw.githubusercontent.com/dsyme/fsharp-presentations/master/generics/BillG%20Review% 202001.pptGoogle ScholarGoogle Scholar
  98. Don Syme. 1993. Reasoning with the Formal Definition of Standard ML in HOL. In Higher Order Logic Theorem Proving and its Applications, 6th International Workshop, HUG ’93, Vancouver, BC, Canada, August 11-13, 1993, Proceedings (Lecture Notes in Computer Science), Jeffrey J. Joyce and Carl-Johan H. Seger (Eds.), Vol. 780. Springer, 43–60. Google ScholarGoogle ScholarCross RefCross Ref
  99. Don Syme. 1995. A New Interface for HOL - Ideas, Issues and Implementation. In Higher Order Logic Theorem Proving and Its Applications, 8th International Workshop, Aspen Grove, UT, USA, September 11-14, 1995, Proceedings (Lecture Notes in Computer Science), E. Thomas Schubert, Phillip J. Windley, and Jim Alves-Foss (Eds.), Vol. 971. Springer, 324–339. Google ScholarGoogle ScholarCross RefCross Ref
  100. Don Syme. 1999a. Declarative theorem proving for operational semantics. Ph.D. Dissertation. University of Cambridge, UK. Google ScholarGoogle ScholarCross RefCross Ref
  101. Don Syme. 1999b. Three Tactic Theorem Proving. In In Theorem Proving in Higher Order Logics, TPHOLs ’99. Springer, 203–220.Google ScholarGoogle Scholar
  102. Don Syme. 2001a. Forum Message. https://web.archive.org/web/20200309165425/https://caml.inria.fr/pub/ml-archives/camllist/2001/02/5770514eec29b794c2d560fc3282bc14.en.htmlGoogle ScholarGoogle Scholar
  103. Don Syme. 2001b. Forum Message. https://web.archive.org/web/20200309165725/https://caml.inria.fr/pub/ml-archives/camllist/2001/02/5ed4e8db99c99cb983fddea7407f5d9c.en.htmlGoogle ScholarGoogle Scholar
  104. Don Syme. 2001c. Forum Message. https://web.archive.org/web/20200309170708/https://caml.inria.fr/pub/ml-archives/camllist/2002/06/8d07fd5058aa26127d1b7e7892698386.en.htmlGoogle ScholarGoogle Scholar
  105. Don Syme. 2001d. ILX: Extending the .NET Common IL for Functional Language Interoperability. Electron. Notes Theor. Comput. Sci. 59, 1 (2001), 53–72. Google ScholarGoogle ScholarCross RefCross Ref
  106. Don Syme. 2002. F#—Combining the speed, safety and productivity of ML and Caml with the libraries, tools and crosslanguage working of .NET. https://web.archive.org/web/20020604234213/http://research.microsoft.com/projects/ilx/ fsharp.htmGoogle ScholarGoogle Scholar
  107. Don Syme. 2005. Welcome to Don’s F# blog. https://web.archive.org/web/20190130121040/https://blogs.msdn.microsoft. com/dsyme/2005/01/05/welcome-to-dons-f-blog/Google ScholarGoogle Scholar
  108. Don Syme. 2006a. Draft Chapter 2 of “Expert F#”: Essential Language Features. https://web.archive.org/web/20190130124706/ https://blogs.msdn.microsoft.com/dsyme/2006/09/06/draft-chapter-2-of-expert-f-essential-language-features/Google ScholarGoogle Scholar
  109. Don Syme. 2006b. F# First Class Events: Simplicity and Compositionality in Imperative Reactive Programming. https://web.archive.org/web/20190205134026/https://blogs.msdn.microsoft.com/dsyme/2006/03/23/f-first-classevents-simplicity-and-compositionality-in-imperative-reactive-programming/Google ScholarGoogle Scholar
  110. Don Syme. 2006c. F# helps show we’re not Neanderthals. https://web.archive.org/web/20190121122515/https://blogs.msdn. microsoft.com/dsyme/2006/12/05/f-helps-show-were-not-neanderthals/Google ScholarGoogle Scholar
  111. Don Syme. 2006d. F# meets LINQ, and great things happen (Part I). https://web.archive.org/web/20190202055324/https: //blogs.msdn.microsoft.com/dsyme/2006/01/26/f-meets-linq-and-great-things-happen-part-i/Google ScholarGoogle Scholar
  112. Don Syme. 2006e. F# on Channel 9. https://web.archive.org/web/20190130125151/https://blogs.msdn.microsoft.com/dsyme/ 2006/09/14/f-on-channel-9/Google ScholarGoogle Scholar
  113. Don Syme. 2006f. Initializing Mutually Referential Abstract Objects: The Value Recursion Challenge. Electron. Notes Theor. Comput. Sci. 148, 2 (2006), 3–25. Google ScholarGoogle ScholarDigital LibraryDigital Library
  114. Don Syme. 2006g. Leveraging .NET meta-programming components from F#: integrated queries and interoperable heterogeneous execution. In Proceedings of the ACM Workshop on ML, 2006, Portland, Oregon, USA, September 16, 2006, Andrew Kennedy and François Pottier (Eds.). ACM, 43–54. Google ScholarGoogle ScholarDigital LibraryDigital Library
  115. Don Syme. 2006h. Lightweight syntax option in F# 1.1.12.3. https://web.archive.org/web/20190130125207/https://blogs. msdn.microsoft.com/dsyme/2006/08/23/lightweight-syntax-option-in-f-1-1-12-3/Google ScholarGoogle Scholar
  116. Don Syme. 2006i. An upcoming experimental feature: Active Patterns in F#. https://web.archive.org/web/20190202055330/ https://blogs.msdn.microsoft.com/dsyme/2006/08/15/an-upcoming-experimental-feature-active-patterns-in-f/Google ScholarGoogle Scholar
  117. Don Syme. 2007a. F# 1.9 almost ready. https://web.archive.org/web/20190130123857/https://blogs.msdn.microsoft.com/ dsyme/2007/03/04/f-1-9-almost-ready/Google ScholarGoogle Scholar
  118. Don Syme. 2007b. Introducing Asynchronous Workflows. https://web.archive.org/web/20191221153257/https://blogs.msdn. microsoft.com/dsyme/2007/10/10/introducing-f-asynchronous-workflows/Google ScholarGoogle Scholar
  119. Don Syme. 2010. Announcing the F# Compiler + Library Source Code Drop. https://web.archive.org/web/20190513075912/ https://blogs.msdn.microsoft.com/dsyme/2010/11/04/announcing-the-f-compiler-library-source-code-drop/Google ScholarGoogle Scholar
  120. Don Syme. 2011. Archeological Semiotics, The Birth of the Pipeline Symbol. https://web.archive.org/web/20190217164203/ https://blogs.msdn.microsoft.com/dsyme/2011/05/17/archeological-semiotics-the-birth-of-the-pipeline-symbol-1994/Google ScholarGoogle Scholar
  121. Don Syme. 2012. More C#/.NET Generics Research Project History. https://web.archive.org/web/20190111203733/https: //blogs.msdn.microsoft.com/dsyme/2012/07/05/more-c-net-generics-research-project-history-the-msr-white-paperfrom-mid-1999/Google ScholarGoogle Scholar
  122. Don Syme. 2018. F# Code I Love. https://www.youtube.com/watch?v=MGLxyyTF3OMGoogle ScholarGoogle Scholar
  123. Don Syme. 2020. The F# Language Specification. https://web.archive.org/web/20200225234105/https://fsharp.org/specs/ language-spec/Google ScholarGoogle Scholar
  124. Don Syme, Gregory Neverov, and James Margetson. 2007. Extensible pattern matching via a lightweight language extension. In Proceedings of the 12th ACM SIGPLAN International Conference on Functional Programming, ICFP 2007, Freiburg, Germany, October 1-3, 2007, Ralf Hinze and Norman Ramsey (Eds.). ACM, 29–40. Google ScholarGoogle ScholarDigital LibraryDigital Library
  125. Don Syme, Tomas Petricek, and Dmitry Lomov. 2011. The F# Asynchronous Programming Model. In Practical Aspects of Declarative Languages - 13th International Symposium, PADL 2011, Austin, TX, USA, January 24-25, 2011. Proceedings (Lecture Notes in Computer Science), Ricardo Rocha and John Launchbury (Eds.), Vol. 6539. Springer, 175–189. Google ScholarGoogle ScholarCross RefCross Ref
  126. Don Syme, Dave Thomas, Ryan Riley, and Tomas Petricek. 2019. F# Compiler Services. https://web.archive.org/web/ 20190829011402/http://fsharp.github.io/FSharp.Compiler.Service/Google ScholarGoogle Scholar
  127. Philip Wadler. 1987. Views: A Way for Pattern Matching to Cohabit with Data Abstraction. In Conference Record of the Fourteenth Annual ACM Symposium on Principles of Programming Languages, Munich, Germany, January 21-23, 1987. ACM Press, 307–313. Google ScholarGoogle ScholarDigital LibraryDigital Library
  128. Philip Wadler. 1995. Monads for Functional Programming. In Advanced Functional Programming (Lecture Notes in Computer Science), Vol. 925. Springer, 24–52. Google ScholarGoogle ScholarCross RefCross Ref
  129. Philip Wadler. 1998. Why No One Uses Functional Languages. SIGPLAN Notices 33, 8 (1998), 23–27. Google ScholarGoogle ScholarDigital LibraryDigital Library
  130. P. Wadler and S. Blott. 1989. How to Make Ad-Hoc Polymorphism Less Ad Hoc. In Proceedings of the 16th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (Austin, Texas, USA) (POPL ’89). Association for Computing Machinery, New York, NY, USA, 60–76. Google ScholarGoogle ScholarDigital LibraryDigital Library
  131. Matt Warren. 2018. How generics were added to .NET. https://web.archive.org/web/20190624152357/https://mattwarren. org/2018/03/02/How-generics-were-added-to-{.NET}/Google ScholarGoogle Scholar
  132. Dave Wecker. 2019. LIQUi|>, The Language Integrated Quantum Operations Simulator. https://web.archive.org/web/ 20190818095124/http://stationq.github.io/Liquid/Google ScholarGoogle Scholar
  133. Wikipedia. 2000. Visual FoxPro. https://web.archive.org/web/20191019042904/https://en.wikipedia.org/wiki/Visual_FoxProGoogle ScholarGoogle Scholar
  134. Wikipedia. 2014. Axum (programming language). https://web.archive.org/web/20200220231711/https://en.wikipedia.org/ wiki/Axum_(programming_language)Google ScholarGoogle Scholar
  135. Wikipedia. 2019a. Harlequin. https://web.archive.org/web/20191014090544/https://en.wikipedia.org/wiki/Harlequin_ %28software_company%29Google ScholarGoogle Scholar
  136. Wikipedia. 2019b. HyperCard. https://web.archive.org/web/20200227223619/https://en.wikipedia.org/wiki/HyperCardGoogle ScholarGoogle Scholar
  137. Wikipedia. 2019c. MLDonkey. https://web.archive.org/web/20200111223533/https://en.wikipedia.org/wiki/MLDonkeyGoogle ScholarGoogle Scholar
  138. Wikipedia. 2019d. Mort, Elvis and Einstein. https://web.archive.org/web/20170818013024/https://de.wikipedia.org/wiki/ Mort,_Elvis,_EinsteinGoogle ScholarGoogle Scholar
  139. Wikipedia. 2019e. ToolBook. https://web.archive.org/web/20190327020717/https://en.wikipedia.org/wiki/ToolBookGoogle ScholarGoogle Scholar
  140. Wikipedia. 2020a. Hindley–Milner type system. https://web.archive.org/web/20200225025311/https://en.wikipedia.org/ wiki/Hindley%E2%80%93Milner_type_systemGoogle ScholarGoogle Scholar
  141. Wikipedia. 2020b. History of Microsoft. https://web.archive.org/web/20191008134013/https://en.wikipedia.org/wiki/ History_of_MicrosoftGoogle ScholarGoogle Scholar
  142. WinWorld. 2016. Microsoft FORTRAN 5.1. https://web.archive.org/web/20161007072505/https://winworldpc.com/product/ microsoft-fortran/5xGoogle ScholarGoogle Scholar
  143. Scott Wlaschin. [n.d.]. F# Day. https://web.archive.org/web/20170701200243/http://fsharpforfunandprofit.com/posts/happyfsharp-day/Google ScholarGoogle Scholar
  144. S. Wlaschin. 2018. Domain Modeling Made Functional: Tackle Software Complexity with Domain-Driven Design and F#. Pragmatic Bookshelf. https://books.google.co.uk/books?id=qA9QDwAAQBAJGoogle ScholarGoogle Scholar
  145. Scott Wlaschin. 2019. F# for Fun and Profit. https://web.archive.org/web/20191221145120/https://fsharpforfunandprofit.com/Google ScholarGoogle Scholar

Index Terms

  1. The early history of F#

        Recommendations

        Comments

        Login options

        Check if you have access through your login credentials or your institution to get full access on this article.

        Sign in

        Full Access

        PDF Format

        View or Download as a PDF file.

        PDF

        eReader

        View online with eReader.

        eReader