Comments

I think PEX and Code Digger are excellent technologies but I would also like to highlight the F# REPL (read-eval-print-loop) called F# Interactive.

When coding with F# its very natural to highlight some code in the editor and just evaluate it interactively.

Specific cases, corner conditions can be easily checked right there as you write the code (you still have to write the tests manually).

There is definitely a feeling of being close to your code and data.

Often times large snippets of code are developed interactively using the REPL and then placed in the main program. This (and the fact F# does not have nulls) means F# programs have much lower error rates (also see http://www.simontylercousins.net/journal/2013/3/7/why-bugs-dont-like-f.html)

Nice to see good energy around F# these days.

The concept of Type Providers is truly a major innovation in language / IDE design.

Even though I have been using F# for a while, I am still learning quite a bit from tryfsharp.org, especially about the applications of F# in the various domains.

How about HTML5 + JQuery Mobile without any JavaScript at all!

Yes its possible with F# and WebSharper.

Check out a live mobile sample here: http://mins.apphb.com .

Source code on codeplex http://ahmobe.codeplex.com

Firstly, a very entertaining and engaging discussion. Nice work Charles!

Secondly, as someone who has done a fair bit of Smalltalk, C#, Java and F#, I and can contribute from my experience.

Smalltalk certainly has the cleanest syntax that  I have seen. It is a pleasure to work in that language (unfortunately it was all but wiped out by Java). It think it is the most stress free language that I can think of.

Now I work mostly work in F# and I believe that I am better off than when I was working in either Smalltalk (or C# or Java).

F# (or OCaml) has strong *type inference* so most of the time it does not *feel* that you are working in a strongly typed language. If you make a change, the types automatically propagate through. If there is a type conflict, the error gets flagged and you can fix it.

While nothing is perfect, F# strikes a good balance between the extremes of Smalltalk and Haskell.

I understand Anders is being very practical and doing the best he can given all of the constraints around web and javascript.

I think instead of a 'language' standard, we should have a VM standard for browsers. If we have a VM standard then we could use any language we want. There will be constraints that all languages will have to adhere to, for interoperability but it's doable. Note both the CLR and JVM have evolved to support a large variety of languages so its technically feasible.

I don't see any standardization effort in regards to a browser VM. Clearly it is needed because javascript can only be taken so far.

Wonderful as always!

Aptly, I just wrote an HTML parser using F# "Active Patterns". The parser/serializer is less than 140 lines of code! (I am claiming it to be the world's smallest HMTL parser until proven wrong).

Please see: http://fshtml.codeplex.com/

Yes, I see that monads are at work (now that C++ has functional capabilities).

Anyone interested in a good monad tutorial can check this out http://www.infoq.com/presentations/Why-is-a-Monad-Like-a-Writing-Desk.

Scala has delimited contintuations (shift / reset keywords) where you can bracket some state that is relevant for your computation and do something with it (save/restore/ship to another location, etc). A stateful web framework could leverage that well, although I don't know of any that does.

Also, one of the useful F# features  is metaprogramming using computation expressions that provides language extensibility (this is like C++ or LISP macros but not exactly). Donna talks about that at around the 45 minute mark. One of the products that leverages it well is WebSharper (http://websharper.com) for generating client side javascript from F# code.

At least one (ivy league) university has made the move to functional programming - Carnegie Mellon.

http://existentialtype.wordpress.com/2011/03/15/teaching-fp-to-freshmen/

Their language of choice is Standard ML.

Here is an F# version  - just for kicks

http://fsviterbi.codeplex.com

See F# source here: http://fsviterbi.codeplex.com/SourceControl/changeset/view/64363#1117175

Test script: http://fsviterbi.codeplex.com/SourceControl/changeset/view/64363#1117178

Some differences:

Actual code (excluding comments) is slighly shorter due to F#'s better type inference and buit-in tuple support.

Path copying is avoided due to 'structural sharing' of F# collections (list in this case)

The double loop calculation is parallelized using TPL wapper "PSeq"  but can be easily serialized. This could be useful for very large state sets on multi-core machines.