Rick Minerich's Development Wonderland : FsCheck

F# Discoveries This Week 06/14/2010 - TechEd Edition

RickM — Mon, 14 Jun 2010 21:25:47 GMT

Despite the small number of talks on F#, it seemed the language was on everyone’s lips this TechEd. Whether working at the Visual Studio Languages booth or hanging out at the parties afterward, almost everyone I talked to was actively investigating or making plans to explore the language.

Of course, this is great news. A quiet tide of interest is quickly rising. Now we just need to give those who are interested the resources they need to be successful and comfortable using F#.

For this reason, each and every F# speaker and blogger is critically important right now. If you haven’t, don’t be afraid to give blogging a try. The F# community is helpful and very forgiving of mistakes. If you are already blogging, consider giving a talk at your local user group or code camp. Now is the best time to help and educate.

News

Daniel Mohl will be speaking at FSUG on 7/5

IT University of Copenhagen uses F# as presentation language in a course: “Programming Language Concepts for Software Developers” (Thanks Pheophan)

Project Emporia Released, on Azure with a F# Core

FsCheck 0.7 Released

Video / Audio

Luke Hoban’s F# in Microsoft Visual Studio 2010 (video) and F# Scaling from Explorative to .NET Component (blog)

The TechEd talk covered a number of interesting aspects of using F# in Visual Studio - tools, core syntax, some examples of current commercial users, and the physical structure of F# projects used in client applications. But the theme of scaling from explorative programming to .NET component is one that I find particularly powerful, and which is a really unique strength of the F# language.

John Hughes on Why Functional Programming Matters (video)

John Hughes is the author of “Why functional programming matters” paper and in this interview he outlines the merits of functional programming and the reason for his involvement with it. He also goes over several core principles of functional programming like monads, handling of side-effects, etc.

Talking Shop Down Under with Joel Pobar (audio)

This week see's Richard talking with Joel Pobar about F# and languages in general. Functional programming is coming more and more to the fore and this is a great episode to find out more about F#, try and get your head around monads and think more about the way you approach programming in general and wether the general purpose languages that you use currently are always the best choice for the job at hand.

Articles

Luke Hoban’s F# Fundamentals on MSDN Magazine

This article takes a look at some of the core concepts of the F# language and its implementation on top of the CLR.

Ashley Feniello’s Wolfram – A New Kind of Turing Machine

Stephen Wolfram’s book, “A New Kind of Science” is flippin’ brilliant! (or perhaps I'm just not brilliant enough to realize he's a mad man) 1,280 pages packed with beautiful insights and Tufte-worthy visualizations. I remember discovering it while randomly browsing the MS library one day. I became so enthralled, an hour passed just standing there reading it!

Vagif Abilov’s Symbolic Calculation in F# on CodeProject

One of the best areas to use a functional language is to apply it to symbolic calculations. Like transforming algebraic expressions or evaluating function derivatives. I remember how I was impressed many years ago when I looked at a program in Prolog that occupied not more than one computer screen but could tell me that derivative of sin(x) was cos(x). So I wanted to do the same in F#.

Don Syme’s HTML5 Programming with F#

Now that WebSharper has been released and matured, it will be great to see it used more widely by F# users. Given the importance of both HTML5 and Silverlight, F# users interested in shipping visualization apps should really make sure they know how to use F# to program these, using the Silverlight SDK (for Silverlight) or tools such as WebSharper (for HTML5).

Chris Smith’s F# active pattern seven-tag limit

Once he went into the theory behind active patterns I agreed that the limit was reasonable and didn't push for us to change the design. This doesn't mean you can't use active patterns with greater than seven tags, it just means that you need to use a different language construct -- the partial active pattern -- instead.

Phillip Trelford’s Runtime Units of Measure for F# and Units of measure auto-conversion

The F# compiler includes a Units of Measure feature which infers a measure type at compile time, which means you get measure type safety with uncompromised runtime performance. […] Sometimes you might also want to actually infer units of measure at runtime, say to display the inferred unit type at the UI. The following F# code prototype provides such inference.

Phillip Trelford’s Silverlight 4 Calculator Sample in F#

The sample demonstrates creating a View in WPF or Silverlight without XAML. The idea is to make things a little easier from F# by implementing a (+) operator overload to attach dependency properties.

Jomo Fisher’s Creating an OData Web Service with F#

If you’d like to take a look at the service I wrote, I published it on Visual Studio Gallery. You just need to go to File\New Project in Visual Studio 2010:

Jon Harrop’s A dragon curve in 17 lines of F#

Dragon curves are a family of self-similar fractal curves. The following 17-line F# program uses Windows Presentation Foundation to visualize the results of a simple recursively-constructed dragon curve.

Neil Carrier’s List<>.collect Implementations with Benchmarks and One more List<>.collect Implementation

I had a situation come up in my proof-of-concept where I needed to do a collect on a .NET List<>. So I did some experiments with how it might best be accomplished. A key factor was that this is something that may be done literally millions of times a day if the application makes it to deployment; so I was concerned with performance.

Neil Carrier’s Easy, No-Compile DFAs

The methods for compiling a set of finite automata DFAs or NFAs into a composite DFA are found in most introductory compiler texts. But how easy is it to construct a simple engine in F# which recognizes a series of patterns? As it turns out, pretty simple.

Neil Carrier’s Surfing the Tuple Pipeline

It turns out that I like the RWFP approach better than mine, but the special tuple pipelines I came up with are not without interest, so I decided to post them here.

Neil Carrier’s This is why I love F# Part One and Part Two

I can’t imagine having any trouble explaining the operation of this program to someone with a basic knowledge of statistics but no computer programming experience. It simply looks like what it does in a way that is succinct and comprehensible.

Daniel Mohl’s The Standard WCF Service Application Template for F#

In the interest of building up a larger set of installed templates for F#, I've ported the standard C# WCF Service Application to F# and packaged it into a .vsi file.

Daniel Mohl’s FSharpCouch: A Simple CouchDB .NET API in F#

To interact with CouchDB, I primarily use Relax (a full featured ".NET API abstraction of CouchDB's (excellent) RESTful API"); however, I thought it might be fun and educational to create a simple CouchDB .NET API abstraction in F#. Note: The code provided here is loosely based on SharpCouch.

Vladimir Matveev’s F# Parsing simple language

During my professional career I often met the task of code generation based on some source data. Last time it was analogue of BCL compiler for ExpressionTrees and then C# compiler have done mostly all the required job with parsing expressions.

Vladimir Matveev’s F# Performance of events and F# Performance of events (update) and Rick Minerich’s A Speedy Alternative to F# DelegateEvents

As you see compiler have inlined code of Trigger method inside Run and accessed field multicast directly. That’s why we replaced let binding with val.

Laurent Le Brun’s F# and FParsec: a GLSL parser example

One of my side-projects is GLSL Minifier. GLSL is the shading language of OpenGL, that is a language designed to run on the GPU, in order to control the graphics pipeline and create nice realtime graphical effects.

Laurent Le Brun’s F# getopt to parse the command line

Many programs (especially console applications) need to parse the command line, and find which options the user want to set. As far as I know, .NET doesn't provide any function for this, but there several third-party libraries to do it.

Yin Zhu’s A note on efficiency in F#, part I: small things first

As a functional programming language, F# programs are kind of high-level, thus harder to reason its performance than imperative programs. Not the big-O thing, it is the constant. This series contains little tips about performance.

Mark Pearl’s F# WPF Form – the basics

I have been keeping my eye out for some examples of creating a WPF form in a F# project and came across Tim’s F# Twitter Stream Sample [..] So today I am going to make just the very basic WPF form with all the goodness of a XAML window.

Mark Pearl’s Simple Mouse Move Event in F# with WinForms

In Thomas’s post he has a form with an ellipse on it that when he clicks on the ellipse it pops up a message box with the button clicked… awesome. Something that got me on the post though was the code similar to the one below…

Ming Tang’s F# Multidimensional Arrays and Jagged Arrays

The problem is that, an array is initialized per every rows, which wastes computational resource. Because the widths of each row are constant, why not make a 1d array and access pixels like y * width + x.

Pheophan’s Fun with Fibonacci

“Horrible performance. fibnaive 40 took 16.6 sec on my laptop" […] “It’s also pretty fast. Here are results of calculating 1000 Fibonacci numbers: Real: 00:00:00.001, CPU: 00:00:00.000, GC gen0: 0, gen1: 0, gen2: 0”

F# Discoveries This Week 03/26/2010

RickM — Fri, 26 Mar 2010 16:47:24 GMT

A ton of new posts this week, far too many to enumerate. My “Favorite New F# Blogger of the Week” (seems like this is becoming a trend) is the mysterious Neil of Techneilogy. I’ve been enjoying his honest exploration of F# and semantic networks very much.

Also, I’ve been hanging around in the ##fsharp channel on irc.freenode.net a bit. There’s a bunch of great people there, some of whom are already using F# at work and are eager to talk about it. Check it out if you have the inclination.

Chris Smith’s Writing a StarCraft Bot in F#

We now have all the pieces in place, but creating an AI-bot for a program not meant to be extended will be tricky. StarCraft Bot 9K has the following architecture, which follows the footsteps of the Java ProxyBot available on the AIIDE Website.

Don Syme’s Video Introductions to F# C9 Series

Who better to lecture on the topic than Don? This three part series will serve as an introduction to F#, including insights into the rationale behind the history and creation of Microsoft’s newest language.

Luca Bolognese’s Tracing spread trades in F# parts one (XUnit and FsCheck) and two (WPF and MVVM).

I have a bunch of spread trades open. Spread trades are trades where you buy something and you sell something else generally in the same amount. You hope to profit from the widening of the spread between the price of the two instruments.

Robert Pickering’s #Develop, F# and Google Summer of Code

Chris told me one area they are interested in extending is the F# integration into #Develop; particularly they’d like to get the auto-completion working. So if you’re a CS student on the lookout for a summer job, you could end up being paid by Google to work on F#!

Robert Pickering’s Beginning F# Workshop and Progressive.Net

I’ll in London on the 10th/11th May giving a two day course entitle “Beginning F# Workshop” in conjunction with the lovely folks at Skills Matter.

Edinburgh University’s Advances in Programming Languages Course, Lecture 19: Heterogeneous Metaprogramming in F#

General overview of metaprogramming, with a range of examples in different languages ranging from C macros through Java reflection to MetaOCaml. Brief summary of the F# language, its history, features, and upcoming release in VS 2010.

Matt Moloney’s Dynamically extending applications using MEF and the new F# CodeDom.

I wrote this little applet to see what the combination of MEF and the F# CodeDom would look like, and for the record it looks really really good. This combination opens a whole lot of doors. By using the F# CodeDom the plugin source code can brought in from anywhere;

Julien Ortin’s Technical analysis indicators in F# – Momentum

This is part of a series on technical analysis indicators in F#, based on the multi-language TA-Lib.

Vladimir Matveev’s Solving Python Challenge with F# – The Chronicles

WARNING!!! If you are going to pass through the Python challenge then stop reading this post, cause it contains solution to 24 level.

Vladimir Matveev’s Data structures: Finger Tree (Part 1.5)

Last time we stopped on “immutable deque” stage. Today we will explore a few additions that can endow deque with super (hmm..human/deque?) powers.

Vladimir Matveev’s Fun with recursion

Recursion is an extremly useful tool in the toolbox of every developer. Many problems have recursive nature and thus best solved with recursion. Tree-like stucture is a very nice candidate for demonstration.

Vladimir Matveev’s F# and WPF or how to make life a bit easier

Not so long ago I was working of small F# script (excellent feature BTW) that performs some data processing and displays summary (using WPF)at the end. All the WPF samples I met in the web utilize object model to create UI, but let's make a confession: making relatively complex UI with object model sucks.

Phillip Trelford’s F# Agents and Retlang: quick comparison

Erlang style message passing is a great way of simplifying concurrency. The open source Retlang library aims to bring some of the benefits to .Net languages like C# and VB.Net. Whereas F# has built-in message passing support with the MailboxProcessor also referred to as Agents.

Neil’s Recap of Tiny Expert System and Next Step in the Tiny Expert System?

Before I move on, let me post a re-do of the the original lazy-evaluated style tiny expert system, incorporating all I've learned about F# over the last couple of weeks.

Neil’s Refined Semantic Network, Data-Driven Semantic Network, Latest Semantic Net Experiment, Yet Another Semantic Network and Semantic Net Search 0.1

Continuing on the path of using classic A.I. tutorial examples to teach myself F#, here is an example using semantic networks. So I created a system in which basic semantic nodes and links can be reified into object instances.

Neil’s Search Using Continuations and Improved Continuation Search

This one returns a list in the right order, and the example shows how to detect circularities. It's a little tricky; the tail recursion involves both a direct tail recursion and a continuation that results in a tail call. I had to run tests to convince myself it really wasn't eating up the stack, lol.

Oliver Strum’s DevWeek 2010 Slides and Samples

Last week I was down in London and spoke at DevWeek 2010. As usual, it was a great conference! Thanks to everybody who attended my talks!

Can Erten’s Happy Pi Day and Monte Carlo Method

Calculating Pi is generally the hello world of Monte Carlo Method in Stochastic Calculus. So for today, I will try to give a sample calculation of pi as monte carlo in F#.

Ade Miller’s NBody.net F# Integrators Code Available

A Forward Euler integrator and a wrapper for it which implements a Barnes-Hut tree code. I’ve blogged about this before. It’s an Octree implementation in F# which uses the asynchronous computations feature to scale across multiple cores.

Matt Davey’s F# and XSD.EXE

Which, thanks to Luke over on the F# Visual Studio team, means I can do this: […] Which now means I can stop hand crafting FpML types in my F# cashflow code.

Ebru Cucen’s F# Samples

If you had the chance to start playing with F#, here are some nice challenges for you. If not you may want to look at from where to start.

Daniel Mohl’s Code Kata and Project Euler - Problems One and Two,

See also: Mike Robert’s solution to problem one and Steffen Forkmann’s solution to problem two.

Recently, I've been thinking about the concept of Code Kata and the personal improvement that this type of practice can bring. I started thinking of types of exercises that I could do to utilize this concept. After looking around on the web, I landed on projecteuler.net and found that the problems listed seemed to fit my agenda perfectly.

Code Camp Hartford 2 Presentation – F# for Testing and Analytics (June 13th)

RickM — Fri, 12 Jun 2009 19:22:00 GMT

I will be speaking at tomorrow’s Code Camp Hartford 2 on the topic of using F# for the Testing and Analysis of existing code. This talk will be composed of much of the same material I used at Code Camp Waltham 11, although I will be preparing additional introductory material as many of my Waltham attendees had no prior exposure to F#.

I hope the audience will find this new introduction short and sweet. In this case my goal will not be to teach F# per se, instead I would like to impress upon the audience the power of using functional programming constructs.

Presentation Details

F# for Testing and Analytics will be held in Room E-Echo at 10:30am.

~~As I often like to make changes up to the last minute, this post will be updated with my slides after the presentation.~~ Slides are now available here.

The Plan

Talk Introduction

Shameless Plug: Upcoming F# User Group Speakers
Survey the audience

F# Introduction

Why F#?
Some Quick and Elegant Examples contrasted with C#

F# Testing Toolbox

For more information, see my post on the Code Camp Waltham 11 Presentation. I wrote quite extensively in that post on most of the things I will be discussing in this talk.

Discoveries This Week 05/17/2009

RickM — Sun, 17 May 2009 21:43:00 GMT

A bit of a slow week. Perhaps some are out playing in the recently fantastic weather instead of blogging about functional programming. My favorites this week were Paul Hudak’s talk on Haskell, Jason Olson’s Channel9 discussion, Niklas Gustafssons’s Actors in F# and Kurt Schelfthout’s Testing DSLs with FsCheck.

Paul Hudak on InfoQ - Haskell

An interview that begins with a discussion of when to introduce difficult Haskell concepts like monads, moves to a discussion of the philosophy of higher order programming.

Paul Hudak, as a principal designer of Haskell, explains FP topics with a passion few others could. Also, I’m curious about this idea of arrows (Freyd-categories) as opposed to monads.

Jason Olson’s on Channel9 - Composing Programming Languages

We talk about his [Lang.NET F# and OO] presentations and his perspectives on object orientation, F# and his own language.

As it seems impossible to pin down exactly what OO is, perhaps we should try to categorize it’s subcomponents across different languages.

Niklas Gustafsson on Actors in F#

One of the advantages of this model over the Axum model is that any number of clients can communicate with an actor, all that is needed is access to the mailbox reference.

I must beg to differ with Niklas on one of his stated disadvantages of the Actor model. It would be easy enough to include a “closing down state” in your Actor FSA. The inability to statically check your agreements is correct though. I’d be interested in seeing a simple Axum sample which could handle N clients and still be statically checked.

Kurt Schelfthout on How to test DSLs (and: FsChecking FsCheck)

It occurred to me that (domain specific) languages seem difficult to test using traditional unit tests: after all, the usage possibilities are far greater for a language than for, say, a typical user interface.

An extremely clever way to test DSLs.

I understand it is exceedingly painful to sign up for an account to leave a simple comment. That given, I am still trying to figure out a solution to my spam problem. For now, if you would like to comment and don’t wish to set up an account, please email me your comment and I will manually post it here.

F# for Testing and Analysis at Code Camp 11 New England

RickM — Fri, 27 Mar 2009 22:36:00 GMT

At this Saturday’s Code Camp I’ll be giving a brand new presentation on using F#. The goal of this presentation is to have those attending leave with an idea of what F# can help them achieve today as well as instill a desire to know more. This post contains my presentation materials as well as links to additional information on the topics covered.

Presentation Details

F# for Testing and Analytics will be held in the TBC (Technical Briefing Center) at 10:30am.

New England Code Camp 11 Information

Download Presentation Slides: F# for Testing and Analysis.pdf

I’ve been thinking quite a lot lately on the best way to get developers excited about F#. By focusing less on the language’s details and more on what the language can help achieve I hope to impress upon those attending why F# is worth the effort. The preliminary structure of the talk is as follows::

Introduction
- Announcing the New England F# User Group
Why F#?
- Time Savings
- Readability
- Code Exploration
- Robust Software
- Power
F# Testing Toolbox
- xUnit.NET
- TestDriven.NET and NCover
- NaturalSpec
- FsCheck
A Real World Example
- Exploring the Problem Space
- Collect, Analyze, Report
- Visualizing Data

Presentation Influences
John Hughes’s Paper: Why Functional Programming Matters
John Hughes’s Talk: FP – A Secret Weapon for Software Testing
Matthew Podwysocki’s 7 Part Series: Functional Programming Unit Testing

Announcing the New England F# User Group

I’m proud to announce that we will be holding our first New England F# User Group meeting on Monday April 6th, from 6:30pm to 8:30pm. It will be held at the aptly named Microsoft NERD center. I hope to see you there.

Visit the F# User Group Homepage for more information.

xUnit.NET

“About a year ago it became clear to myself and Brad Wilson that there were some very clear patterns of success (and failure) with the tools we were using for writing tests. Rather than repeating guidance about "do X" or "don't do Y", it seemed like it was the right time to reconsider the framework itself and see if we could codify some of those rules.”

xUnit.NET Homepage

Learn More about xUnit.NET
Matthew Podwysocki’s The Unit Testing Story in F# Revisited
Jim Burger’s Unit testing in F# with xUnit.NET
Harry Pierson’s Practical F# Parsing: Unit Testing

TestDriven.NET and NCover

“TestDriven.NET is a zero friction unit testing add-in for Microsoft Visual Studio .NET. The current release of TestDriven.NET supports multiple unit testing frameworks including NUnit, MbUnit and MS Team System and is fully compatible with all versions of the .NET Framework.”

TestDriven.NET Homepage (Includes a free version of NCover)
NCover Homepage

Learn More about TestDriven.NET and NCover
Matthew Podwysocki’s F# + TestDriven.NET + xUnit = Win
Matthew Podwysocki’s FP Unit Testing Part 4 – Code Coverage

NaturalSpec

“The idea of NaturalSpec is to give domain experts the possibility to express their scenarios directly in compilable Unit Test scenarios by using a Domain-specific language (DSL) for Unit Tests. NaturalSpec is completely written in F# – but you don’t have to learn F# to use it. You don’t even have to learn programming at all.”

NaturalSpec Homepage

Learn More about NaturalSpec
Steffen Forkmann’s “Getting Started” with NaturalSpec
Steffen Forkmann’s Testing QuickSort with NaturalSpec
Steffen Forkmann’s Using NaturalSpec to create a spec for C# projects

FsCheck

“FsCheck is a tool for testing .NET programs automatically. The programmer provides a specification of the program, in the form of properties which functions, methods or objects should satisfy, and FsCheck then tests that the properties hold in a large number of randomly generated cases.”

FsCheck Homepage

Learn More about FsCheck
Claudio Cherubino’s Random testing in F# with FsCheck
Matthew Podwysocki’s FP Unit Testing Part 2 – QuickCheck and FsCheck
Kurt Schelfthout’s FsChecking dnAnalytics Part 1, Part 2 and Part 3

FsStory

“FsStory is a library for writing executable user stories in F#. FsStory enables the developer to write user story scenarios (in Given/When/Then form) in F# code.”

FsStory Homepage

Learn More about FsStory
Gustaf Nilsson Kotte’s Fluent language in FsStory
Gustaf Nilsson Kotte’s FsStory, executable stories in F#