Inside Microsoft's New F# Language

robyn217 writes "There's a new language being formed in the bowels of Microsoft. Recently I got word that the language F# (pronounced F Sharp) is nearing workable stages at Microsoft Research. So, I went in for a look-see. What I found was an interesting blend of imperative (Java, C#) and functional languages(it's ML-based, too!). It looks pretty enticing to me from a computer science perspective, but I'm not sure it would fly in the professional market. I can see the ease of development that a language loosely based on ML would bring, but I can't see coders switching over in droves since it's a tough learning curve." Our previous story on F#.

Comments

That's how I feel about most Microsoft languages

[The Lord of Chaos]

F#ing Visual C++
F#ing VB.
F#ing Win32 API

It's OCaml for the .NET CLR...

[Anonymous Coward]

It's OCaml for the .NET CLR. Not a new language. Nothing to see here. Move along.

Re:It's OCaml for the .NET CLR...

[Zeinfeld]

It's OCaml for the .NET CLR. Not a new language. Nothing to see here. Move along.

Yes, but the problem with most ML implementations is that they are academic toy languages. You can't do anything useful with them because you can't connect them to real I/O and if you can you can't distribute the code as noone else has the environment.

Adding the dotNET classes to ML means you have a real programming environment for a functional language.

Re:It's OCaml for the .NET CLR...

[Junks Jerzey]

Yes, but the problem with most ML implementations is that they are academic toy languages. You can't do anything useful with them because you can't connect them to real I/O

In all honesty, what are you talking about? You can pick up OCaml right now and I/O is just fine. Period.

if you can you can't distribute the code as noone else has the environment

So everyone has to use C forever and ever?

Re:It's OCaml for the .NET CLR...

[arkanes]

There's a signifigant inertia to overcome with the acceptance of any new language. One of the barriers is the creation of a useful runtime, porting that runtime to common platforms, keeping it supported, etc. There's a whole bunch of languages out there, but probably 90% of applications are written in less than a dozen of them (Java, VB, C, C++, Delphi... am I missing anything else major?).

One way to overcome that inertia is to provide bindings for your niche language against a major runtime - like compiling it to Java bytecode, or, in this case, IL.

Now, .NET has it's own inertia to overcome, but because it's Microsofts baby, it has alot of advantages that the language/runtime that Joe Programmer makes doesn't have.

This is interesting for a couple other reasons - it's been reported before that it should be easy to port functional languages to .NET - and that it's apparently hard to have them compile to Java (I don't know crap about functional languages, I'm just parroting here), so here's the proof of that. Also, like it or not, .NET is very big and is being very heavily pushed by the single most influential company in IT - and if you're a fan of functional languages, I don't see how this is a loss for you or why you're bitter about it.

Re:It's OCaml for the .NET CLR...

[MillionthMonkey]

(DISCLAIMER: I didn't write this myself- we were having an email conversation about F# today at work, and this is what our CEO had to say about it. I got his permission to repost his email here but he insisted on editing a few comments disparaging to Microsoft because he wants to encourage them to keep working on it.)
--snip--

F# seems to be based very closely upon ocaml, which was the language that I used for day to day work before Java.

I think ocaml is a fantastic language, although, like everything, it had a few significant problems five years ago:
- obscure [ F# could fix this ]
- not as many libraries as a mainstream language [ F# could fix this. ]
- not great module support - if module A depends on B, then B cannot depend on A.

Disclaimer: everything I say comes from personal, but old, experience, and a cursory look at the F# web site.

Interesting properties of ocaml:
1) Functions are first class objects. E.g..
let add x y = x+y;
let add3 = add 3;
print (add3 4);
-> 7
2) Polymorphism works well. So you could define a function that takes an array of objects x and a function that maps x to y, and produce an array of objects y. Eg
let a = [| 5,6,7 |] // an array of integers
print (Array.map add3 a)
-> [| 8,9,10 |]
3) Type checking is strong, compile time, and usually implicit. All types in the examples above are deduced correctly. Disadvantage: You can't have operator overloading, even for the plus sign... so + means integer addition, and +. means double addition.

4) You can return multiple values from a function
let cis t = (cos t,sin t);
let (ct,st) = cis (PI /. 2.0);
print ct;
-> 0.0

5) Variables are final by default, but can explicitly be made not-final. There are also control structures that make many things that one does in Java by changing variables simpler. This can make debugging simpler, but takes a while to get used to.

6) There is some very powerful pattern matching code - imagine a more powerful case where you could say

int x;
Point y
switch (x,y) {
case 7,null: do this
case 4,Point(3,?) : do that
case x,Point(y,x) : print y
default:
}

[ Actually, there is no direct concept of null, but that is not the point. ]

I particularly liked ocaml as it allowed imperative features, had GC and exceptions, and had a very good compiler that produced fast code. I was very impressed by the French academic group that made it and supported it.

[ Note examples are not valid ocaml - they are ocaml features with a javaified syntax to make them easier to explain, and besides, I have not used the language for years. ]

The current F# implementation does not sound very efficient for a variety of reasons. It is also not nicely polymorphic in the same way that ocaml is. This defeats a lot of the point of it. They need support for generics in the VM for these to work well. There is a different group at MS research working on this - I would be delighted if both the F# project and the generics project make it into the mainstream.

It is not clear how well the ML view of types will match up with the C# view of types. ML programming feels different to Java programming, and this could make the .NET library matching clumsy. But if they could make it work, then that could get rid of two of the biggest perceived issues that have prevented widespread adoption of ocaml.

--snip--

Re:It's OCaml for the .NET CLR...

[John Whitley]

can't connect them to real I/O

This used to be true ten years ago, but you are way out of date. OCaml works great for I/O. If available Debian packages are any measure, OCaml has had quite the active and growing developer base too.

The major semantic hurdles for even (mostly-)pure functional languages (c.f. Haskell) were solved many years ago. (Look up the papers of John Launchbury, Simon Peyton-Jones, and others on State Transformers in Haskell. See also papers about how the use of the 'monad' from category theory introduced an incredibly powerful tool into languages such as Haskell). The Fox project at CMU used Standard ML to create a nifty layered TCP/IP stack and HTTP sever back in the mid 90's.

The various current functional languages may have issues, social and/or technical, w.r.t. mass adoption... but the I/O problem definitely isn't one of them anymore.

Yes !!!

[dago]

I knew that someday Fortran will make its comeback and becomes the all mighty programming language !!!

Figures...

[da3dAlus]

I usually use an F#-word or two when dealing with one of Microsoft's programming languages. This is great for marketing "See, everyone's shouting praises of F(sharp)!".

This isn't all apparently...

[CrazyJ020]

A microsoft rep met with us a couple of weeks ago pushing .NET, win2k3, the whole enchilada. He mentioned they have MANY of these languages in development and are due to be released in the next year or so. They will still be pushing C# for mainstream development. The other languages will focus on niches where a modern OO language would be cumbersome.

He wouldn't confirm whether they would have the X# naming convention ;)

Re:This isn't all apparently...

[esarjeant]

I like different languages, there are applications where Perl is more effective than C and where object oriented makes more sense than procedural.

It looks like Microsoft is going to provide me a dream palette of languages to pick from. Maybe this will help make things like Design By Contract a little more mainstream?

OTOH, there is a right way and a wrong way of approaching this. In the example of DBC, MS would do good by providing an Eiffel implementation for their CLR. In the example of F#, MS would be more correct to introduce Scheme and LISP dialects rather than invent their own.

Not because these languages are perfect, but because developers are already familiar with these environments. We can't continue to "invent" new ways of doing things, the software industry has been introducing new standards at such an astonishing rate that we may jeopardize our ability to maintain legacy systems that are generationally distanced. Systems that were maintained 10 or 20 years ago rely on technologies that a recent college grad will be entirely unfamiliar with.

Very few industries have this kind of halflife, let's not make it worse with [Aa-Zz]#.

Re:This isn't all apparently...

[Hard_Code]

Customers don't pay for intractable problems to be solved. They pay for new icons.

Re:This isn't all apparently...

[MisterFancypants]

OTOH, there is a right way and a wrong way of approaching this. In the example of DBC, MS would do good by providing an Eiffel implementation for their CLR. In the example of F#, MS would be more correct to introduce Scheme and LISP dialects rather than invent their own.

Bertrand Meyer is one of the biggest .NET boosters on the planet, and he already oversaw a port of Eiffel to .NET. This was available like a year ago.

There's also a Scheme compiler, called Hotdog, with a .NET backend:

Keep in mind that F# is but one of MANY language research projects going on at Microsoft Research, and there are many more going on at other sites that Microsoft is tangentially involved with.

F sharp or F hash?

[SomethingOrOther]

Heh
In the UK we call that square thingy a hash

Do you think C hash has done well here :-P Will F hash do any better?

(Or does "making a hash of it" get lost in the translation?)

Re:F?

[Tsali]

Actually, after rereading, doesn't python's lambda or use of functions as objects address the same problem space as F#? (per the author's example on the "What's the purpose of F#?" page of the article? My python's rusty, but, isn't that one of the cool things about python? Couldn't a C# delegate do something similar? Can you tell VB is my native tongue? :-)

We have been working with it for a while.

[ayjay29]

When developing for windoes "Microsoft F#&%", or "F#&%*!? .net" is the most common language our team uses.

Gee Flat

[snatchitup]

Do you relize that an F# major has 6 sharps.

But, an F# is the same as a Gb (G flat) which has as 6 flats.

Now the C# scale has 7 sharps, but it's the same as a Db (D flat) which only has 5 flats.

Most people think (D flat) instead of C#.

F# is a very bright scale. It sounds very nice on an Alto Saxophone, whereas the C# scale is a little more moody, depressed.

Maybe Microsoft is trying to back off the use of C#.

Re:Gee Flat

[sammy baby]

I'd hesitate to say it's a "bright scale" in and of itself. The intervals between tones are the same in F# as in C#, which is why the whole circle-of-fifths thing works in the first place. The brightness or moodiness of the scale is entirely dependent on the range and tonal qualities of the instrument on which it's played - try it on a piano, and one doesn't really sound brighter than the other.

And besides, everyone knows that D minor is the saddest of all keys.

Re:Gee Flat

[Alioth]

Now all they need is G# (or Ab) and you can play the blues with Microsoft languages. Somewhat appropriate :-)

Could be useful?

[DrTentacle]

Our company has recently started to introduce .NET development alongside our core J2EE platform. One of the issues that has come up has been how useful the multi-language/single-platform support would be. Rather than taking a "best of breed" language for all development, the use of the right tool for the right job could potentially lead to interesting results - A mix of C#/ML/PROLOG/etc. as appropriate for the immesdiate task at hand. I don't think MS is far enough down the road yet to capitalise on the idea, but it's certainly an intriguing possibility - Even if it would lead to a maintenance nightmare :)

Re:Could be useful?

[brlewis]

In reality, Microsoft's CLR is only slightly better than the JVM at accommodating multiple languages. Better support is "planned for a future release", much like the 1993 promises of WinNT that came out in 2001. All the languages ported to the CLR had to be compromised somehow, same as those that compile to JVM bytecodes. I'm still hoping dotnet will push Sun to extend the JVM to be more acommodating of non-Java languages. For example, it would be fun to try full continuations in BRL pages.

Funny quote of the day

[26199]

Map then applies whatever function we pass in to every member in the array (called a list in functional programming).

So, all you functional programmers, remember... a list is just another name for an array :-P

Seriously, though... I was discussing the future of programming languages with some friends and we agreed that a real step forward would be to provide features such as higher order functions in a mainstream language... could this be it?

If so then it's a little worrying... I'd rather not see any revolutionary languages come out of MS, if at all possible...

(Cambridge's Computer Science degree teaches ML followed by Java in the first year... would they switch to teaching just F# if it became popular?)

Re:Funny quote of the day

[Dan Ost]

Seriously, though... I was discussing the future of programming languages with some friends and we agreed that a real step forward would be to provide features such as higher order functions in a mainstream language... could this be it?

If you consider Python to be mainstream, then there's already a mainstream language that supports both functional programming and advanced types like lists and associative arrays (aka dictionaries).

I stumbled on to Python about a year ago and have been so impressed by it that it's becoming my languange of choice for new development.

Check Python out. Really

Re:Funny quote of the day

[Eudoxe]

In France, students learn Caml during their first year before school of engineer. Maybe this will help the devel of ML in industry.

Re:Funny quote of the day

[jaoswald]

What's "wrong" (rather, missing, or inconvenient) is the ability to fill f with pointer to functions that were not defined when the compilation happened.

In Lisp, I could take the contents of a Web form, for instance, and use that to make a function that would encode, for instance, your preferences in music, then use that newly-formed function to rate MP3's as your are browsing.

(defun make-rating-function (web-form-contents)
(lambda (music)
(+ (* (country-rating web-form-contents) (country-genre music))
(* (rock-rating web-form-contents) (rock-genre music))
(* (classical-rating web-form-contents) (classical-genre music)))))

Then, that rating function can be stored in a variable for later use on the music.

You could implement this in C, by storing the array of three values, but it is much less flexible. My make-rating-function could return one out of any number of functions, which take different information out of the web-form-contents. For instance, classical music listeners have very different ways of choosing music, so you would give them a music-rating-function that looked at composers more than performers, while rock fans would look more at bands that groups of people tend to rate similarly.

(defun make-rating-function (web-form-contents)
(if (classical-music-lover web-form-contents)
(make-classical-rating web-form-contents)
(if (rock-music-lover web-form-contents)
(make-rock-rating web-form-contents) .....

where make-rock-rating is written as above.

Once you make the choice of functions depend on the data, it becomes cumbersome to do in C. It's like doing polymorphism in C: you need to start making case statements all over the place to check what kind of customer you are dealing with. Lisp makes this kind of stuff easy to express---dealing with functions is as easy as dealing with integers and floats.

I like the idea

[Anonymous Coward]

My first year CS classes were taught in ML. It's a very potent language. I especially liked the type inference system. What other languages do in templates comes naturally in ML. Our CS prof gave us an example of Quicksort in 3 lines of readable code. As an academic language ML has problems interfacing with real life systems. OcaML was a step in the right direction and MS is building F# on it. I'll certainly try this one.

Related to Harlequin ML

[shic]

I wonder if F# has any relationship to the "ML for Microsoft" (I forget the name) efforts from Harlequin Software a few years ago? ML has always seemed an ideal fit for many single-user RAD developments, it just needed an appropriately stable, complete, clearly specified component library and professional quality IDE in order to reap productivity benefits over Java/C# et al.

Re:Well...

[henbane]

F# will be learned by people when managers and not university lecturers decide that it is something that coders need to learn or even when coders decide it's necessary for something.

Stop thinking that the world is out to make you use MS products no matter what. The businesses that do the employment and the people who should be advising them (cough -you- cough) are the people who make those decisions.

Anyone learning Computer Science should in no way be gearing themselves with any particular product

Any university offering courses in computer science is doing students a dis-service if it sends them out of the institution without an MS-centric, Linux-centric or any other square peg solution to fit any hole they come across.

I always thought the aim of education and particularly any discipline that considers itself a science was to teach skills and thinking which could be applied across the field so the graduates would find themselves able to adapt to any language or equipment that they found it necessary to use.

Microsoft Attempt to Own the RIAA

[dduardo]

If they can patent/trademark/copyright all the notes used in music, they will be able to own the RIAA.

The have: C#,F#
Left: A,A#,B,C,D,D#,E,F,G,G#

Can't wait for the other 10 programming languages

Re:What will they do?

[NeoSkandranon]

No, they'll go A through G, then start making chords and arpeggios.

Re:What will they do?

[RayOfLight]

... the drive letters team is (still) working this one out.

Re:Wrong... you couldn't....

[xenocide2]

Which only goes to show how much cleaner mapping functions to lists is.

map (fun x -> x*x) list

Re:What will they do?

[BigJimSlade]

What will MS do when they run out of letters in the alphabet for their language du jour?

In newer versions of .NET, you will be able to mount new languages underneath the old language:

C#:\NewLanguage

This will eliminate the need for the old "Lettered Language" scheme that has haunted us since the DOS era. It will be revolutionary!

Why I like Java...

[Eric_Cartman_South_P]

...the way I wrote a file to a disk 5 years ago is the same way I write it today. And I know how to write a file to a disk on Solaris, Linux, Mac, BSD and Windoze since I know the little bit of code that does it in Java. Although a simple real world example, it is pretty powerfull stuff when you think about it. And remember, NO RELEARNING.

I know, AWT->SWING and a bunch of other examples, but a CORE PART of Java does not change. It remains the same as much as possible, in regards to the API.

MS goes ahead and changes things completely every few years. Java, for the most part, does NOT require tons of relearning. The API's are there if you need them, but a majority of them do not change. They might get "cleaned up" a bit, or a few deprecated here or there, or in my opinion a few too many may be created to do the same task, but if you could knock up a Java prog years back, it's the same way today for the most part. SIMPLE.

F-hash

[wadiwood]

The only time I read a # as "sharp" is when it is on a musical staff ie five parallel lines. Otherwise it is a hash as in #5 for number 5 or please press the hash key on the phone.

hash definitions

Of course when ever I see F# and Micro$oft together I read F#$%

The description reads like F# is OCaml on hash ie dumbed down.

Re:F?

[thermostat42]

As one of the posters above mentioned, python's lambda is actually borrrowed from the Functional programming world. I believe it originally gets its name from Lambda Calculus, but mathematicians will have to correct me on that. (I first saw it in Scheme, the most beautiful programming language I've ever programmed in, if not the most practical.)

If you've never done functional programming, it a different animal from imperitive programming, and if you do know python, it borrows a number of things from FP, not just lambdas. Look at python's map, apply, and reduce functions, along with list comprehensions (taken from Haskell, which I really need to learn). Although, it should be noted that python's recursion really isn't optimized for FP, but you can still do quite a few things that a functional programmer would be at home with.

After reading this article...

[Shant3030]

I strongly suggest that Microsoft stick to making operat...(um), office pro..., (no thats not it...), web brow...(nope), how about video game...(nah)..., programming platfor...(not it either)...

Re:After reading this article...

[alexjohns]

They make pretty good Mice and Keyboards.

Re:F?

[jgerman]

We call that the monetary unit soon to be known as the Euro.

# == Hash

[Anonymous Coward]

Microsoft says it:

F#ism is finally back in F#ion.

I guess this means all Microsoft programmers are F#ists.

Oh well, they're only in it for the C# anyway.

Re:Gee C# was so flawed that its already supercede

[swb]

And computing is so fundamentally simple. Its a game of N-Dimensional topology bounded by finite vectors in every dimension. There's no mystery involved. You just need to maintain a meta-model of the system and you can generate the rest.

Christ, if that's simple, I'd hate to hear you describe complicated.

Haskell next?

[axxackall]

While I like ML (whole family) so much more than any imperative legacy (Java, C++, C, Perl), I see the main problem that any ML has with for modern RAD and with scripting is its static typing. And that's why I like (more than ML) Haskell - it's dynamically typed and thus it's much more appropriate both for operating scripting and for big app RAD.

Until today, both ML and Haskell had a common problem: a lack of commercial and real world interest in it and therefore a lack of real-world libraries and supporting frameworks. But now things are going to be changed.

First Ericson came with Erlang, an excelent essence of FP, LP, scripting and networking. Now M$ (I know - evil, but anyway) came with F# bringing OCaml to the real world saving from being forgotten somewhere in Inria.

What next? I think that would be Haskell, the language even more suprior to ML, with already OOP, Parallel and Cuncurrent extensions. Also I like its Functional-Logical dialect - Curry. But who will bring it to the real world? IBM?

Re:Haskell next?

[KieranElby]

I wouldn't bet against Microsoft bringing Haskell to the real world - their research department (which would put many universities to shame) has some top Haskell people, such as Simon Peyton Jones.
There's some interesting papers by him over here.

Re:Haskell next?

[milesegan]

Haskell is most certainly not dynamically typed. Like ML, it is a statically typed language with a compiler that does type inference at compile type. You don't usually have to manually declare types but you still have to get them right at compile time. There are some differences between ML's type system and Haskell's but they're basically the same animal.

ML and Haskell differ mainly in that ML is an eager language, which evaluates all arguments to functions before evaluating the function. Haskell is a lazy language which delays evalution of function arguments until their values are needed.

Erlang, on the other hand is dynamically typed.

The process now understood

[carlos_benj]

There's a new language being formed in the bowels of Microsoft.

This may help explain Microsofts process for developing new software. How are things "formed in the bowels" anyway? A simple understanding is that good stuff is essentially chewed to pieces and then deconstructed in an acidic bath. Once the good stuff reaches the bowels then an attempt is made to remove everything that is of value. Once that has been accomplished we are, I suppose, left with a Microsoft product that is ready to (careful here now) ship (Whew! Now that was one major Freudian slip just waiting to happen....).

Imperative and functional lanuages

[jfengel]

It's usually a very bad idea to include imperative aspects in functional languages.

Functional languages are amazing creatures. They're really strange to work in. They take a serious change of mindset. They can be very slow to execute. I/O is really odd when side effects are forbidden.

They have astounding benefits, too. The localization of effect means that they're really easy to debug. The lack of side effects means that some really enormous optimizations are open, which is crucial since the naive execution is slow.

Once you throw in any imperative aspects at all, these effects go right out the window. Even a single imperative statement potentially interferes with every optimization. ("Can I eliminate this execution branch? It seems like a redundant call but it might branch to that imperative statement.")

I think that this got in the way of ML. It can be easy to want to add just a tiny imperative element to make something easier, but that small crack opened up a lot of headaches for me. I greatly preferred the purity of Haskell.

I haven't read the F# spec, so I may be overreacting from the notoriously inaccurate Slashdot summary. That's next.

Functional Programming

[jefu]

Functional Programming is a Very Good Thing to learn.

After being interested in functional programming languages for a while I had the opportunity to spend some time reviewing a textbook using ML. I figured that was the time to learn the language. Got frustrated quickly, I got several ML systems (including the one mentioned in the book) and no two worked alike. Hell, the syntax varies enough that there are ML dialects that look like completely different languages.

A while later I decided that perhaps it was time to spend some energy seriously learning Haskell. I got and installed Hugs (Haskell.org is a wonderful resource with several Haskell systems listed, tutorials, documentation, libraries and so on). Hugs implemented pretty much all of the Haskell described in the manual I found and the tutorials. (Today, I'd probably use the interactive GHC.)

It took a while, some dedication and a lot of grumbling to figure out how things worked and I'm still learning bits and pieces of the language and associated libraries and stuff.

Now Haskell is one of my favorite languages and I want to use functional tools (higher order functions, laziness, and so on) in every language I use. I'd say that Haskell changed my ideas about programming, my approach to problems, and my toolset both deeply and widely - and for the better. Probably as deep a shift in technology and technique for me as OOP (I started programming in Fortran, APL, Algol...) - but then OOP just always seemed Right to me.

Part of what made the learning process so effective was that Haskell makes it very hard to have side effects - so where in ML the books/tutorials often introduce mechanisms for building variable that work more or less like those in C - in Haskell this is very difficult.

So, while F# may be an interesting language, if you want to learn a new language, try Haskell. You may have to be obstinate. And if it works with you as it did me, it will drive you crazy until it clicks (and I remember exactly the problem that did it) and then you'll just kind do one of those quiet awestruck "wow"s and watch your view of programming change.

Haskell isn't the right language for everything. I also use Java, C and Python (and a few others) often - but for lots of problems, for doing a quick model of something to try it out, for just helping your mind think about a problem a bit differently ... Haskell is great.

But remember - you may well have to be stubborn about persisting till it clicks.

And on a related note...
Does anyone know if anything ever came out of the development of the functional scripting language "Sheep" for the amiga?

Microsoft's next language

[Webmoth]

Rumor has it that Microsoft is working on a "lite" version of F# to be called "F Micro" or "Fu" for short.

Oh wait, their lawyers already use it. Must be past beta then.