Combining the efficiency, scripting, strong typing and productivity of ML with the stability, libraries, cross-language working and tools of .NET.
F# is a programming language that provides the much sought-after combination of type safety, performance and scripting, with all the advantages of running on a high-quality, well-supported modern runtime system. F# gives you a combination of
* interactive scripting like Python,
* the foundations for an interactive data visualization environment like MATLAB,
* the strong type inference and safety of ML,
* a cross-compiling compatible core shared with the popular OCaml language,
* a performance profile like that of C#,
* easy access to the entire range of powerful .NET libraries and database tools,
* a foundational simplicity with similar roots to Scheme,
* the option of a top-rate Visual Studio integration,
* the experience of a first-class team of language researchers with a track record of delivering high-quality implementations,
* the speed of native code execution on the concurrent, portable, and distributed .NET Framework.
The only language to provide a combination like this is F# (pronounced FSharp) - a scripted/functional/imperative/object-oriented programming language that is a fantastic basis for many practical scientific, engineering and web-based programming tasks.
F# is a pragmatically-oriented variant of ML that shares a core language with OCaml. F# programs run on top of the .NET Framework. Unlike other scripting languages it executes at or near the speed of C# and C++, making use of the performance that comes through strong typing. Unlike many statically-typed languages it also supports many dynamic language techniques, such as property discovery and reflection where needed. F# includes extensions for working across languages and for object-oriented programming, and it works seamlessly with other .NET programming languages and tools.
For those of you unaware, F# is now a first class MSFT language, or in other words, this is no longer a “Hey, here’s an idea. Let’s research it.”-type project and instead a true-blue MSFT product backed by mean-green MSFT money, led by some of the very best and brightest minds @ MSFT.
If you were to ask me “What’s the future language foundation of the .NET platform?” I would first state “More than likely, XSLT 2.0++.” And then when you stopped laughing and slapped me upside my head to awake me from my dream I’d say, “What the F#!? was that for?” and you’d say “F#??,” followed by “Isn’t that for programming the way God intended for people to program on the .NET platform?”, and then I’d say “Okay, you got me on that.” at which point we’d move on…
So here’s the thing: While there are *TONS* and *TONS* of reasons why F# *ROCKS* (did I mention that F# is distributed as both an MSI and a ZIP, the latter designed to make it easy for folks using Mono to take full advantage of what F# has to offer?), the biggest reason it *ROCKS* is this,
An update to the F# 1.9.3 release has been posted to the Microsoft Research Downloads site. Additional changes between126.96.36.199 and 188.8.131.52 are:
* Constructed classes may now be mutually recursive with other types, fixing an incompletness in the language implementation
* The Microsoft.FSharp.Core.Func module is deprecated (this contained a few rarely used functions related to function values themselves)
* The prefix operators “%” and “%%” have been added as ASCII-equivalent for Unicode section marker operators used for splicing into quoted expressions (i.e. for data binding into quotation expressions).
* Some additional identifiers in Pervasives have now been marked with the ‘OCaml compatibility’ attribute. We recommend people cross compiling with OCaml use –no-warn 62. [ Note: this may be a bit verbose for those cross-compiling F# code with OCaml and using these APIs heavily. In the next release we expect this warning will be off for all files ending in extension “.ml”. ]
* Bug fixes, including some installation and documentation bugs
Okay, so maybe the above doesn’t make it obvious what I mean by “this”, so let me be a bit more forthcoming: F# is a live, active, and vibrant project which releases updates several times a year, if not more often. So when I say “this is the future programming language of the .NET platform.” what I really mean is that I hope to dear God that MSFT keeps the momentum going, changing the “a new release once every couple years” pattern to instead a constant flow of incremental updates that allow us hacker types the ability to begin incorporating the latest and greatest ideas from the best and the brightest minds sooner rather than later, in a format that allows us to provide constant feedback on how MSFT can make things better, faster, more reliable, and most importantly: Allow us to become more efficient in our day-to-day programming, a trait that is inherent to functional programming languages in general, and a trait that I hope spreads like a virus to each and every language that is pwnd by a product team at MSFT.
So why does F# *ROCK*? Because it has the potential to not only completely change the way we hacker types write code, but to completely change the way MSFT does business (UPDATE: At least as it relates to “Developers, Developers, Developers!” ;-): Fast, agile, responsive, with the community at the center of the entire process. That’s why F# *ROCKS*.