Rick Minerich's Development Wonderland : quotations

F# Discoveries This Week 01/29/2010

RickM — Fri, 29 Jan 2010 19:15:34 GMT

Many apologies if I missed your post. Having skipped last week due to some uncontrollable circumstances left me with quite a large number to sort through. My personal favorite this week is Ashley Feniello’s series. SICP eat your heart out.

Richard Morris’s Geek of The Week is Don Syme

“It came as a surprise to many of us when Microsoft pulled from it's hat a rabbit in the form of an exciting, radical, language that offers an effective alternative to the Object-oriented orthodoxy. The creative force behind this language, F#, turns out to be a brilliant Cambridge-based Australian called Don Syme, already well known for his work on generics in .NET.”

Ashley Feniello’s extremely cool eight part (so far) series FScheme:

“One of my New Year’s goals is to re-read Lisp in Small Pieces and implement all 11 interpreters and 2 compilers. As much as I like the "Lisp in Lisp" idea and enjoyed the eureka moment in SICP when Sussman writes the metacircular interpreter on the board to the music from Space Odyssey, I don't want to do Lisp in Lisp itself. Lisp in F# sounds like more fun.”

Part 1: FScheme - Scheme in F#
Part 2: Just ‘let’ Me Be Already!
Part 3: Lambda the Ultimate!
Part 4: Rinse and Recurse
Part 5: What ‘letrec’ Can’t Do
Part 6: What's Lisp Without Lists?!
Part 7: No Wait, Macro the Ultimate!
Part 8: Oh, The Humanity!

Matthew Podwysocki’s Series - Creating Extended Builders Part 1, Part 2 and Part 3

“But, what we lack is an imperative programming model on top to allow for such things as if statements, for and while loops, and try/catch or try/finally blocks. Luckily, there is a programmatic model to follow to make these things possible inside of our expressions. Let’s cover each of these functions in turn and see what each one does and in the process implement them for the Reader Monad.”

Chris Smith’s Being an Evil Genius with F# and .NET

“Rather than doing the prototypical “Intro to F# Talk” I figured I go with something a bit more fun and relevant to the every day developer. Sure F# is neat and everything – but why bother to learn a new programming language unless you can use it to do something meaningful. Well, in addition excelling at both functional and object-oriented programming, F# is ideal for world domination.”

Tomas Petricek’s Accelerator and F# (IV.): Composing computations with quotations

“In this part of the series, we're going to look at working with quotations explicitly. We'll use meta-programming techniques to work with Accelerator. Meta-programming means writing programs that manipulate with other programs or pieces of code.”

Luke Hoban’s Tuning a Parallel Ray Tracer in F#

“One of the samples that is included with the Parallel Programming Samples for .NET 4 is a simple Ray Tracer. This ray tracer provides a nice visual way of seeing the benefits of .NET 4 parallelism features, as well as giving insights into the way work stealing happens under the hood.”

Julien Ortin continues his series on Purely Functional Data Structures with a Scheduled binomial heap, Scheduled bottom-up merge sort and a Hood-Melville queue

“This post describes the F# implementation of the <insert data structure here> from Chris Okasaki’s “Purely functional data structures”.”

Julien Ortin’s Rate meter in F#

“The following code allows us to measure (and keep track of) the exchange rate (whether upload or download), and the time needed to exchange n additional bytes (assuming the rate is stable).”

Julien Ortin’s Two-way traffic control in F# – bucket approach

“The following approach is based on a per-request basis. That is, an actors asks for n tokens to read (or write), and the manager sends it an answer when the actor is allowed perform the action. In effect, if the actor asks for 100 bytes and only 50 bytes can be exchanged per second, it will get a green light only after two seconds have elapsed.”

Stasyan continues his Red and Black tree Series with Insertion, Deletion, Extras and a Post-Mortem.

“But it works nevertheless. I did some random testing of 10000 elements. Insertion and deletion worked. The cool thing is that the Black height of the tree with 10000 elements does not exceed 10.”

Granville Barnett Review’s F# for Technical Computing

“An F# book by Jon brings with it excitement and promise: his work is well known for being clear and concise, and the examples he uses to help the reader familiarise themselves with the application of F# are highly stimulating.”

David Worthington’s WebSharper platform seeks to broaden F# use

“Microsoft's F# language is best suited for financial and scientific applications, but a startup wants to broaden its usage to building mainstream Web applications.”

Ade Miller’s Implementing a Parallelized Octree in F#

“What’s an octree? An octree is a tree structure where each node has up to eight children, one for each of the octants. You can think of them as a three dimensional variation on a binary tree.”

Diego Echeverri’s Data Visualization with Websharper

“In this post I'll show you how to make a nice visualization similar to the ones used by Hans Rosling. For this, we'll use the WebSharper Google Visualization bindings available as an extension package to the core platform.”

Matt Manela’s Regex based Lexer with F#

“This lexer allows you to define your regular expression based rules in a very declarative way using F# computation expressions.”

Phillip Trelford’s Sorted with F# custom operators

“F# lets you define your own operators, and like a man with a new hammer hunting for nails :) I’ve found an application of F# custom operators for sorting multiple columns.”

Chris Rizzuto’s Http Requests in F# using a TCPClient

“Obviously a few ways to do this using WebClient, HttpRequests, but in this case I decided to use a TcpClient object as I liked the control, and the ability to easily access the textual outputs.”

Chris Rizzuto’s F# WCF Service to calculate StdDev and Keep Real-Time KPIs, F#, WCF, KPIs, ConcurrentDictionary, First Class Events and Message Queues in F# / Building into the KPI Service

“First, below is the functions and events to calculate StdDev. Thanks again LukeH for doing all the work for this part. I only made a small change by adding a new method for handling the event when it is raised, and to make Mean and StdDev accessible from a WCF web service so that if polled for the current values, it is able to return them to the user.”

Cameron Taggart’s List Transactional WCF Bindings in F#

“The code uses LINQ to print a list of WCF binding that have a default constructor and support transactions. I think it actually is a whole lot more readable in F#”

Cameron Taggart’s Hello World for Bing Maps + Silverlight + F#

“The Bing Maps Silverlight Control was released in November. […] I’ve committed code for this blog that shows you how to get started with it using an F# Silverlight application. I did not need to write any C# or XAML.”

Scott Seely’s F# is Changing My Style

“A few years ago, I would have done a bunch of looping constructs to look at each element. However, I’ve been doing a lot more work with F#. While doing this experiment in C# for a project, I wound up writing the following instead:”

F# Discoveries This Week 01/05/2010

RickM — Tue, 05 Jan 2010 21:10:05 GMT

It’s 2010, the year of F#, and the quantity of posts in this last week reflects it. Not to pick favorites but the work Tomas Petricek has been doing with Accelerator is amazing, be sure to check it out.

Also, I’d like to thank everyone who supported me on the road to becoming a Microsoft MVP. I couldn’t have done it without you.

Tomas Petricek parallelizes Quotations with Accelerator

In this article, we'll look at more sophisticated way of using Accelerator from F#. We'll introduce F# quotations and look at translating 'normal' F# code to use Accelerator.

Don Syme Posts updates his F# JAOO tutorial code

I've now updated this tutorial code for the F# Visual Studio 2010 Beta2 release (with matching CTP release for Visual Studio 2008). We've also added some more content and explanatory comments.

Matthew Podwysocki investigates the State Monad

In the past, I’ve had a series on Much Ado About Monads where I look at the basic Monads such as Maybe and List, but this time, let’s look at what we can do with the State Monad.

Adam Granicz shows off WebSharper at the Hungarian Web Conference

In this talk, I will present our new web development platform, WebSharper(TM), that leverages the power and expressiveness of F# to allow .NET developers to write robust web applications in mere hours.

Chance Coble and Ted Neward release DZone Refcardz for F#

This DZone Refcard will lead you through the basic essentials so that you can quickly move on to using this Functional Programming Language for creating some mind-bending code.

Talbott Crowell posts his FSUG Parallel Programming Talk

In this video, I discuss some of the advantages of .NET 4 and F# for asynchronous programming plus some of the new analysis tools built into Visual Studio 2010 for visualizing concurrency.

Steffen Forkmann creates a ‘FAKE – F# Make’ group on BitBucket and releases version 0.17

Due to its integration in F#, all benets of the .NET Framework and functional programming can be used, including the extensive class library, powerful debuggers and integrated development environments like Visual Studio 2008 or SharpDevelop, which provide syntax highlighting and code completion.

Julien Ortin continues his series on Purely Functional Data Structures with a Physicist Queue, a Lazy Binomal Heap and a Bankers Queue

This post describes the F# implementation of the <insert data structure here> from Chris Okasaki’s “Purely functional data structures”.

Mathias Brandewinder StackOverflows on Unit Testing with F#

So far, my process with F# has been to write some functions, play with them with the interactive console until I am "reasonably" sure they work, and tweak & combine. This works well on small-scale problems like the Euler Project, but I can't imagine building something large that way.

Chas Emerick demonstrates the problem with mutable objects

316 arguments to a method (which I don't think is actually possible in the jvm, but bear with me)? "That's absurd!", you'd say. The problem, of course, is that the 3-arg doSomething actually has far more arguments than its signature implies:

A Mysterious Stranger implements a Red-Black Tree

Both 2-4 and Red and Black tress are self balancing trees. They are kind of like cousins, since one could be converted into the other quite easily. Hence all performance analysis that apply to 2-4 trees applies to Red and Black trees.

Mark Needham discusses expressing intent with application operators

While trying out Roy Osherove's TDD Kata I realised that perhaps the choice of which of these to use or whether to use them at all depends on what intent we're expressing.

Discoveries This Week 04/03/2009

RickM — Sun, 05 Apr 2009 01:42:00 GMT

With the start of our F# User’s Group this next Monday and New England Code Camp 11 last weekend, things have been extremely busy this past week. Meanwhile, the F# sociocosm is growing at a rapid pace. This week we have a talk by Don Syme, a look at F# quotations, and finally, some discussion on Seq.unfold.

Chris Bowen’s Post, Announcing F# User Group in Cambridge - April 6

A shameless plug here for our new user group. A big thanks to Chris for helping us find the resources we needed to start out. Without him this might never have come together.

Don Syme’s Talk, F# and functional programming in .NET

As Don Syme is the father of F#, when he speaks the community listens. In this talk Don focuses on the pleasure and speed inherent in using FP and F#. He does this by describing the functional methodology and constructs which provide a simpler and more elegant model for building programs.

Alex P’s Post, F# quotations at their simplest

A simple example on the surface for sure. However, if you haven’t seen the power of F#’s language oriented programming features this is sure to be of interest.

For a deeper look at the power of quotations check out Tomáš Petříček’s F# quotations visualizer. If his past projects are any indication Tom’s upcoming book is a must have for any F# enthusiast. I preordered a copy just today.

Martin Peck’s Post, Solving Problems in C# and F# - Part 2
(and update)

One of the most fantastic things F# has to offer is the rich functional programming heritage of sequence operations. To demonstrate how elegant they can make your code, I would like to offer the following alternative F# solution:

let fibs = 
  Seq.unfold (fun (a, b) -> Some( a, (b, a+b) )) (0I, 1I)

Seq.find (fun n -> n >= 10I ** 999I ) fibs

I’m going to take this opportunity to point out the obvious: we have here two lines of F# which does almost exactly the same thing as thirty six of C#. Now that’s what I call power and elegance. The unfold function pretty much does exactly what yield was doing before, but implicitly in terms of the unfold function. The idea of unfold can be confounding at first and so here is a breakdown of how it works:

let fibs =
  Seq.unfold 
    (fun (a, b) -> //generator function, 
                   //(a, b) is the previous state
      Some //Option monad, needed for unfold
        (a, (b, a + b))) //returned tuple: (value, state)
                         //or (first, (second, third))
      (0I, 1I) //Initial function state (first, second)

Note that in this version the state of the next two values in the sequence are always pre-calculated. However, it is easy to avoid this if you instead consider the state in terms of the previous two values:

let fibs = 
  Seq.unfold (fun (l, l2) -> 
    let n = l + l2 in Some( n, ( n, l ) ))
    (0I, 1I) //(previous, second previous)

If you want to learn more about unfold I recommend checking out:

Dustin Campell’s Post, Apples and Oranges

This is the best description of how unfold works I’ve seen to date.