Sunday, March 22, 2009 4:09 PM
Discoveries This Week 03/20/2009
This week there seems to be quite a bit of video and audio content to share. We have a dramatic depiction of the benefits of Units of Measure, Luke Hoban on F#’s feature, Ted Neward talks about F# under the hood and finally a discussion on operator type inference.
A fantastic example of how static dimensional analysis of scalar values could prevent an entire class of bugs. In the past, I’ve talked about what a huge fan I am of the Units of Measure package for F#. I’m glad that others also see how revolutionary units of measure are.
Would you want to work in a building or live in a house in which the engineers who built it did not keep track of units? I don’t think anyone would answer yes. Similarly, we should not entrust our lives or livelihoods to software in which these very same things are not kept track of.
In this podcast Luke Hoban, the F# program manager, discusses about various aspects of F#.
- Mutability comes along with .NET Framework support.
- Statically Typed means strong guarantees and so robust systems.
- FP design in the small for concurrency
- OO design in the large for scalability
- Explorative programming via interactive window
- Influenced heavily by Haskell
- FP as a technique, not a class of languages
Ted Neward gives an in-depth presentation on both how F# works under the hood and the general benefits that stem from FP in general. The examples used are simple but Ted covers them in a very exhaustive way.
Beyond the language and concepts therein, he also has a number of insightful comments about teaching people to use F#. In particular the idea that F# syntax will be easy to teach but functional programming technique will take years really struck home with me.
In his post Kalani points out a small but significant logical inconsistency in F#’s type inference system. The issue seems to stem from the way type inference is handled for basic operators. Instead of working generically, they each have default types.
From his post:
val it : (int -> int -> int)
> 3.2 + 5.4;;
val it : float = 8.6
> let twice x = x + x;;
> twice 9.4;;
stdin(2,5): error FS0001: This expression has type
float but is here used with type int.
To get around this, he then goes on to build a function which takes an operator and both arguments. However, this workaround is completely unnecessary. You need only to annotate the function’s input and it works without issue.
> let twice (x: double) = x + x
val twice : double –> double
> twice 9.4;;
val it : double = 18.8
Now, it’s important to note that this version of the twice function won’t accept an integer. In fact, it was a conscious design decision to disallow function overloading in F#. In both F# and C# all kinds of overloading must be qualified by type. That is, type methods support argument overloading but free floating functions do not.