planet wmassdevs articles

F# Discoveries This Week 09/03/2010

One of the greatest things about running this blog, other than having a structured way to read all of the F# community content, is that I’ve been able to watch the community grow in a very concrete way. Looking back to a year ago there was only six posts on F# over the course of a week, now we have well over twenty. It’s truly amazing to see.

Now, on to the links.

Audio and Video

Dr. Ralf Lämmel's C9 Lectures: Advanced Functional Programming - Type Classes

“In this second lecture in the series, Ralf digs into Type Classes, which are type system constructs that were originally introduced to provide a form of ad hoc polymorphism (i.e., an advanced form of overloading).”

Rick Minerich's Functional Language Paradigms with F#

“I've got great news. F# is here and is poised to increase your productivity and reduce your suffering.”

Peter Sestoft's Teaching programming language concepts with F#

“Peter introduces the curriculum, lecture plan and lecture notes for the course "Programs as data" that uses the functional programming concepts in F# to teach students language concepts and implementation details.”

Tools

Essential F# | Refcardz

“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.”

fsxplat - Released: FSharp packages 1.2

“F# packages and samples for use across platforms”

Phillip Trelford's TickSpec: An F# BDD Framework

“Right now TickSpec is intended as a lightweight framework to get you started with BDD using F#. It is standards based, supporting a subset of the Gherkin language, so should be easy to change to another Gherkin based framework like Cucumber, SpecFlow or StorEvil.”

General

Vladimir Matveev's F#: Building compiler from sources.

“Of course, compiling them sources and observing all internal compiler activities, so to say “in action’.”

Ashley Feniello's Fixing Decades-old Bugs in the HP-35

“To make an assembler, I just parse with a series of regular expressions. F#’s active patterns came in super handy for this! In fact, the assembler turned out to be fewer lines of code than the disassembler.”

Ashley Feniello's Microcode-level HP-35 Emulator (in JavaScript!)

“I had the (silly) idea of building a JavaScript-based emulator. Looking at Peter Monta’s Python-based disassembler and his object code listing, it looked simple enough to automatically generate script from David Cochran’s original bits. I wrote my own little straight forward 100-line disassembler in F#, producting an array of JavaScript functions”

Brian McNamara's F# for puzzles (Morse code decoder)

“The idea is simple; the computer works out all the possibilities for the next 3 letters, and then the human selects which prefixes “look promising” to investigate further.”

Neil Carrier's TechNeilogy: Fuzzy Logic F# Reference Module: Fuzzy0

“Below is the fuzzy logic reference code for module Fuzzy0. Tomorrow I’ll post an example of its use that explores some extensions of earlier techniques.”

Yin Zhu's F# and Data Mining: WekaSharp: Tutorial for using Weka in F#/.Net

“The minimal wrapper in F# for Weka.”

Daniel Markham's Structuring Larger F# Functional Projects

“So here's a suggested structure outline for those larger functional projects”

Ade Miller's F# Samples for Parallel Programming with Microsoft .NET

“We’ve been working with the F# Team to get the samples for Parallel Programming with Microsoft .NET ported to F#.”

Neil Carrier's TechNeilogy: F#, Fuzzy Logic, WPF, and Tomatoes!

“This is my 100th blog post, and to celebrate, I’m pulling out all the stops. This example will combine F#, fuzzy logic, WPF, and tomatoes!”

Neil Carrier's TechNeilogy: Conjunctive Fuzzy Logic Rules in F#

“It shows how to make multipart conjunctive rules by storing the input sets in a list and using the “min” operator to combine the results into a truncation height. To do this, it adds vector versions of the fire and fire all functions.”

Justin Angel's Windows Phone 7 supports VB.Net and F#

“In this article we’ll review Windows Phone 7 support for the Visual Basic .Net and F# programming languages. Our goal is to demonstrate that Windows Phone 7 can indeed support F# and VisualBasic.Net code libraries and user controls.”

F# Artificial Intelligence Library Tutorial

“This step-by-step tutorial describes how to use the library in fsx script and C# project.”

Chris Marinos's 5 Reasons to use F# Interactive in Visual Studio 2010

“I find that I use F# Interactive more for performance analysis, learning F#, and verifying Base Class Library behavior than for spiking or scripting.”

Community

Stack Overflow - Calling F# (.Net dll) code from php

“Yes you can, by using PHP COM class but it works only on Windows version of PHP5+ and needs no separate installation.”

Stack Overflow - Scrap Your Boilerplate in f#

“I've used the Scrap Your Boilerplate and Uniplate libraries in the Haskell programming language, and I would find that form of generic programming over discriminated unions to be really useful. Is there an equivalent library in the f# programming language?”

Stack Overflow - Path to Become a Better F# Programmer

“What should be my steps from now on to become a better/professional F# programmer?”

Teaching and Basics

Bill Morrissey's Learning F# for C# developers: Scope, Workflow and Lists

“This post is part two of a series of posts looking at syntactical examples of F# and C#. This post will supply you with easy to understand F# coding examples.”

Anders Hesselbom's Type inference in F#

“I have recently been to a short F# presentation at HiQ in Arboga. One of the things that got mentioned was type inference.”

Rey Dacoco's WebBrowser control (Visual F# Windows Forms Application)

“WebBrowser control is a control used to display a web page or web document. To create a WebBrowser control in F#, use the following syntax:”

WordCram: Open-Source Word Clouds for Processing

I just released a project I’ve been working on for a while, called WordCram. As the title says, it’s a Processing library for generating word clouds.

I found wordle.net a few years ago and really liked it, and after seeing the code for Algirdas Rascius’ Scattered Letters on OpenProcessing.org, I tried making some of my own. It was fun, but I thought it ran too slowly to bother bundling it into a Processing library.

After reading the Wordle chapter from Beautiful Visualization, I learned a few new tricks, and it’s a bit faster now, so here it is. There’s still work to do, but that’s the fun part.

A different kind of URL shortener

Today I'm launching my first Google App Engine site. While I built it largely to play with GAE, it is also useful in its own right (I like to think so anyway). It does two different things:

Link shortening without redirection. Put in a godawful long Amazon link and get back a shorter Amazon link. Works with eBay and a few others too. I welcome recipes for other sites. (For the programmers in the audience, which is most of you -- yes, the processing is via regular expressions.)

It does some basic checks to confirm that the shortened URL returns the same page as the original one.

Link expansion. Put in a link from a URL shortening/redirection service, e.g. bit.ly, and see where it redirects to. Works with a slew of popular link-shorteners, including the house brands goo.gl and nyti.ms.

Some of the shortening services do offer a way to see the link target before you visit it, but they're all different; this presents a simple unified interface to that feature.

There's a bookmarklet too. If you have someone in your online life who frequently bombards you with, say, mile-long eBay links, tell them about it.

http://urlworks.appspot.com/

F# Discoveries This Week 08/27/2010

I’m back again with another edition of F# Discoveries this Week. The most exciting announcement this week is the new F# August 2010 CTP which brings with it the ability to build your own VS2010 F# Express Edition with Visual Studio Shell and the prospect of building F# applications on Windows Phone 7. Be sure to check out Daniel Mohl’s Windows Phone 7 template before getting started.

News and Upcoming Talks

F# (August 2010 CTP)

Announcing the F# 2.0 Standalone Tools Update

A standing invitation to F# users to "get in touch"

Don Syme lecturing at the F#unctional Londoners Meetup (9/9)

Tools and Libraries

WekaSharp: An F# wrapper for Weka (Yin Zhu)

F# and C# Win Phone List Template (Silverlight) (Daniel Mohl)

fsai Release FSharp AI library 1.10.0 (Lukáš Kouřil)

RockScroll: my new favourite Visual Studio Add-In (Kean Walmsley)

Video, Audio and Slides

Slides and samples from F# talk in Manchester (Oliver Sturm)

F# Intro Talk at NextGenUG in So’ton (Phillip Trelford)

Slides from Combinators, DSLs, HTML, and F# (Robert Pickering)

Busy .NET Developer’s Guide to F#: Basics (Ted Neward)

Technical Articles

iTunes via F# Interactive (Cameron Taggart)

F# for puzzles (Morse code decoder) (Brian McNamara)

Extracting elements from Win32 resource files (Luis Diego Fallas)

A variation on Matt Moloney's "Memento" pattern (Don Syme)

Bound Variables in F#: What Reflection Reveals (Neil Carrier)

Getting F# Running on a Continuous Integration Server (Ade Miller)

How F#'s async really works? (George Cullen)

Segment Tree in F# (Neil Carrier)

Bound Variables in F#: What Reflection Reveals (Neil Carrier)

Fuzzy Logic Experiments in F# (Neil Carrier)

Fuzzy Logic in F#, Example 1 (Neil Carrier)

Fuzzy Logic in F#, Now More Functional! (Neil Carrier)

F# “fun” with Windows Phone 7 (Fahad)

Getting started with Windows Phone in F# (Senthil Kumar)

Euler Problem 10 (Mark Pearl)

Euler Problem 16 (Mark Pearl)

Project Euler Problem 9 in F# (Stefano Ricciardi)

Project Euler Problem 8 in F# (Stefano Ricciardi)

Project Euler Problem 6 and 7 in F# (Stefano Ricciardi)

Enumerable.Skip vs Seq.skip (Mauricio Scheffer)

Getting Started and Evangelism Articles

Putting the fun in functional programming (Daniel Markham)

Back to school : Getting to know F# (Mehfuz Hossain)

Learning F# by writing C# (Alan Hemmings)

F# - sharper than C# (Josh Reuben)

Learning F# for C# developers (Bill Morrissey)

F# Community

Ars Technica - What do you think of F# ?

SO - How to merge sorted sequences in F#.

SO - Which to use, C# or F#? In this "real world" case

hubFS: F# Databse Application Samples & Articles

hubFS: MailboxProcessor.TryScan paradigm

Meeting This Week, Thursday August 26!

We have another meeting coming up this week on Thursday, August 26th. We’ll be meeting up at Panera Bread in Hadley. That’s on 353 Russell Street in the strip mall with the Wal-Mart and the Barnes and
Noble.

Attendance has been light lately, if could post to our mailing list to let us know your coming, we’ll make our best effort to reserve enough seating.

Topics

This will be a pretty casual meeting, we’ll be gathering towards the back and everyone will be free to talk about whatever they like. Usually we end up clumping into a couple of groups.

Schedule

Lastly, here’s a rough outline of our schedule…

07:00 - 09:00 — eat, meet and mingle

F# Discoveries This Week 08/15/2010

Tons of great links along with a brand new less cluttered format today. Let me know what you think on twitter.

News / Talks

Talbott Crowell at San Fancisco Bay Area F# Users Group (8/16)

Don Syme at the Community for F# Online (8/17)

Luke Hoban will be giving a F# keynote at CUFP (10/2)

Joel Pobar "Smart Software with F#" at JAOO (10/6)

Podcasts / Screencasts / Videos

Perspectives on Clojure and F# (with Rich Hickey and Joe Pamer) (Joey deVilla)

Advanced Functional Programming - The Expression Problem (Dr. Ralf Lämmel)

The Language Matters on the Software Engineering Productivity Podcast (Rick Minerich)

Articles

Undo / Redo using the Memento Pattern and Command Pattern in F# (Matt Moloney)

A variation on Matt Moloney's Undo/Redo "Memento" pattern (Don Syme)

Hindley Milner Type Inference Sample Implementation (Edmondo Pentangelo)

INotifyPropertyChanged strikes back (Vladimir Matveev)

WebSharper, part 2: WebExcel (Vladimir Matveev)

OOP Virtualization vs. F# Discriminated Unions (Neil Carrier)

Segment Tree in F# (Neil Carrier)

A F# Silverlight Template (Daniel Mohl)

Reading F# Projects, Part I: The Common Knowledge (Yin Zhu)

Reading F# Projects, Part II: F# Set (Yin Zhu)

Reading F# Projects, Part III: The F# math providers. (Yin Zhu)

Query Zune Music Collection with F# (Cameron Taggart)

How to merge sorted sequences in F# - Stack Overflow (Neil Carrier)

Combining memoization and tail-recursion – Stack Overflow (Ronald Wildenberg)

"I think F# is very cool" - Rich Hickey (Flying Frog Consultancy Ltd.)

F# – Euler Problem 10 (Mark Pearl)

Seq.unfold (Bohdan Szymanik)

Back to school : Getting to know F# - Mehfuz's WebLog (mehfuzh)

Slides from Combinators, DSLs, HTML, and F# (Robert Pickering)

Steve's Tech Talk : Using a Proxy Class to Fix F# Protected Access ... (Steve Hawley)

Tools

FastSharp 2.0 (Matt Manela)

NDjango 0.9.8 (Michael Feingold)

F# Project Extender 0.9.3 (Michael Feingold)

Quantifa: F# open-source project for quantitative finance and risk management (Don Syme)

VsVim (Jared Parsons)

F# Discoveries This Week 08/08/2010

So many links, all well worth your time. I know one thing I won’t be missing is Don Syme’s online talk at C4FSharp on 8/17. It’s great to be part of a language community in which the founder interacts in such a direct way.

News

Draft F# Component Design Guidelines now Available (pdf)

Don Syme will be speaking online for the Community for F# on 8/17

I’ll be speaking at the NYC ALT.NET User Group on 8/25

Kevin Hazzard’s Slides from DevConnections are up

Howard Mansell will present Eden: (An F#/WPF framework for building GUI tools) at CUFP

F# is now at 93% on langref, only 1% behind scala. (Great Going!)

PexForFun.com now has puzzles for F#

FSharp Cross Platform Packages and Samples 1.1 Released

Audio/Video

Jon Harrop at the London F-Sharp User Group: QR Decomposition

This lecture takes the audience from a tiny numerically-robust implementation of a common linear algebra algorithm through several stages of optimization, culminating in a high-performance solution that easily outperforms Intel’s Math Kernel Library. The algorithm studied is QR decomposition, which is commonly used for linear least squares best fit.

F# Articles

Adam Granicz’s Expert F# 2.0 – what’s new?

There comes a time when you just have to stop working for a minute and take a few moments to enjoy the fruits of your hard labor. For me, one of these moments lately came when I received the author copies of our book, Expert F# 2.0

Daniel Mohl’s F# Templates Now On Visual Studio Gallery

As Don Syme mentioned in a recent blog post, I've been working to get the five F# templates that have been announced on this blog up on Visual Studio Gallery. I'm happy to say that all are now available.

Vagif Abilov’s Mock framework challenges in F#

So far I only tried very basic mocking described in the first post of Richard’s series: faking return value. As I expected, even such a simple operation became a challenge when executed from F# code. I managed to make tests work only for two and half frameworks.

Mauricio Scheffer’s Figment: a web DSL for F#

As I said, this is very much work in progress, and there's still a lot to do. I intend to make it fully open source when I finish writing my thesis.

Neil Carrier’s Segment Tree in F#

Suffice to say that a segment tree stores a group of intervals on an ordered set, in such a way that all the intervals containing a given value can be efficiently located. Such a query is sometimes called a “stabbing query,” because it’s like sticking a spear through the data and seeing which entries get stabbed.

Neil Carrier’s F# Sequence Lazy Evaluation Gotchas

Today’s post will be old news to experienced F# programmers. Actually, it’s old news to me, relative newcomer that I am. However, it’s one of those things I tend to forget until it jumps up to bite me, as it did today.

Edgar Sanchez’s F#, the ACM, and the SEC

And it is this last recommendation on DSLs that carries interesting news for F# because at the end of page 6 it states “Experience seems to show that higher-order programming languages such as F# provide a particularly good basis for domain-specific languages.

Jon Harrop’s Pure F# now only 2× slower than OCaml

This is a surprising and encouraging result not only because it makes F# competitive for an even wider variety of tasks but because it also implies that Microsoft are taking F# so seriously that they are optimizing the .NET garbage collector for it!

Steve Hawley’s Protect Yourself

One solution is to label things that need to be protected, disassemble the output, run a regular expression to search/replace the accessibility and reassemble.

F# and .NET needed at Credit Suisse? Is there a future for this and Microsoft in the quant world?

As I said, when you compare to these other languages in the world of quant, F# appears to be taking an early lead.

Stefano Ricciardi’s Project Euler Problem 4 in F#

The actual algorithm uses brute force to test for palindromicity (neologism?) all the numbers that can be composed multiplying together 3 digits numbers (those from 100 to 999), picking the highest one.

Miscellaneous

Lambda the Ultimate’s OSCON 2010 Emerging Languages Camp Roundup

Making Xcode's Build and Analyze much better

A few weeks ago, I discovered that the Build and Analyze in Xcode didn’t find as many problems as scan-build did directly when you turn all options on.

On the Clang analyzer site, they have instructions for setting up the latest analyzer so that Xcode would use it. Unfortunately, the settings that find some very common problems are off by default. Here are instructions for getting the Clang analyzer to run with those options on.

To make sure you are doing it right, make your project completely succeed a Build and Analyze, then comment out a release that you are doing in any dealloc. Rerun Build and Analyze -- it should not find this problem.

Then,

1. If you don’t have it, download and untar the latest checker
2. Make a script file called full-analyze-clang and put it in the checker’s bin directory, with this code

#!/bin/bash
CLANG="`dirname $0`/clang"
CLANG_CMD="\"$CLANG\" -Xanalyzer -analyzer-check-objc-missing-dealloc -Xanalyzer -analyzer-check-objc-missing-dealloc -Xanalyzer -analyzer-experimental-internal-checks $*"
eval $CLANG_CMD

3. From the Terminal, run this command to make the script executable

chmod +x full-analyze-clang

4. In the checker root directory, there is a script called set-xcode-analyzer. Run it like this:

sudo ./set-xcode-analyzer --use-checker-build=FULL_PATH_TO_CHECKER/bin/full-analyze-clang

replacing FULL_PATH_TO_CHECKER with the path to the checker directory where you untarred it in step 1.

5. To test, Run the Build and Analyze on the project you set up with the bad dealloc. If it finds 0 errors, this could be because something is wrong with the way the script is set up.

Important parts if this stops working with a future clang:
The set-xcode-analyzer expects a directory or a full-path to clang. It checks to see it has a full-path by looking for a path ending with “clang”, which works for us because our script’s name ends in “clang”. If they change this script in the future, this might not work

Build and Analyze just reports a successful build if our script reports errors -- it’s just looking for the existence of result files. You might need to add logging lines to the script to figure out what’s going on. Log to a full-path because the current directory is inside Xcode’s path somewhere when the script is run.

Use something like this as your last line to debug:

eval $CLANG_CMD > `dirname $0`/cl.out 2> `dirname $0`/cl.err

Get iPhone programming tips in your inbox with my Beginner iPhone Programming Tips newsletter.

F# Discoveries This Week 07/30/2010

It’s Friday and once again I’ve gathered up more F# content for your viewing pleasure. If you happen find yourself in the Boston area this next Monday come meet me for our New England F# User Group meeting. We are always happy to have new people interested in checking out functional programming.

News

VS2010 Keyboard Shortcuts Now Available in Letter and A4 Size

F# samples are 74% complete on langref.org (nudge nudge)

Two Contract Positions: F# Interactive in Silverlight

Scott Theleman will be speaking at New England FSUG on 8/2

Audio / Video

eXpress Persistant Objects and the F# Language

Articles

Don Syme’s Some F# Project Templates Available Online and Daniel Mohl’s An F# Silverlight MVVM Mutli-Project Template

If you have your own templates or projects-that-could-be-turned-into-templates, here are the steps to make and publish a template to the Visual Studio Gallery, making it really easy to access by the whole community.

Ben Hutchison’s Study Functional Programming or Be Ignorant

Right now, if you want to understand the state of the art in computer programming, those are your choices as I see them.

Bohdan Szymanik’s Heat/Image Mapping with .NET/F#

Most of the effort was spent aggregating and binning the data, the actual image prep was trivial. The following assumes you have an array of data to display.

Neil Carrier’s Cartesian Product of Lists in F#

So without further ado (other than to note that all the code here is presented "as-is" and without warranty or implied fitness of any kind; use at your own risk) here is my Cartesian product of lists code.

Jared Parsons’ Converting System.Func<T1..TN> to FSharpFunc<T,TResult>

Interop of delegate style types between F# and other .Net languages is a pain point that results from a fundamental difference in how delegates are represented in the F# language.

Steve Hawley’s Limit Your Memoization, Please

So the lesson in this (and in many CS problems) is that you need to really understand the specific domain of your problem before applying a sweeping technique like memoization.

Cameron Taggart’s Exploring the GAC with F# and Mono.Cecil

Mono.Cecil can be used to look inside assemblies. May be you want to search GAC to find types that implement a certain interface. In this post, I’ll show how to find all the types that implement IDisposable as an example.

Cameron Taggart’s Find Authenticode Signed Assemblies

Mono.Security can be used to check for the presence of an Authenticode signature on a assembly.

Gary Short’s XPO – F# Lists and Seqs Oh My!

Let’s assume we have a small database of people and we wish to calculate the combined age. The functional method of doing that would be to “fold” the elements of a collection of People over a function that accumulates the age of each person, in an accumulator value, which is threaded through the fold.

Mark Pearl’s F# Euler Problem 9

After some more thinking, I decided to use tuples instead and generate the permutations using the Seq.unfold method.

Maurizio Colucci’s How F# adapts to the way we think – part1

This is the first episode of a series meant to show how easily F# adapts to the way we think. I assume no knowledge of functional languages, but I do assume knowledge of an imperative language such as C#.

Wiston Gubantes’ F# Asynchronous Programming

Async programming in functional languages such as F# is such a breeze....

Community

Stack Overflow: Immutable data structures performance

Stack Overflow: Functional Reactive F# - Storing States in Games

Xcode 4

There are two great things about Xcode 4 that mean I had to download and try it right away

It runs side-by-side on the same machine as Xcode 3.2
It uses the exact same project file format

This hasn’t been the case in the last few major upgrades from what I remember, and I was really glad to read that in the release notes.

My first impressions after an hour or so:

Putting the view in Assistant mode (Opt-Cmd-Enter) is really nice. Shows the .m when editing the .h and vice versa. When editing an .xib file, it shows the ViewController.

Keeping the Interface Builder dialogs organized as parts of a single window is also a big win. It’s confusing having them as free dialogs. Specifically, having the parts of the main dialog (File’s Owner, First Responder, View, etc) as just part of the chrome (and always visible) is nice.

I think I’ll really like the Log Navigator -- especially for debugging. I am constantly clearing the console, but this saves each one in a separate view so I can keep them around.

The Project Navigator is so much cleaner (replaces the Groups and Files tree). It always felt like Xcode just stuffed everything there instead of organizing it elsewhere in the GUI. However, it took me a long time to figure out where Build Settings were (click the project name in the Project Navigator), but it seems obvious now.

Build and Analyze still doesn’t find dealloc omissions of retained property releases. I would like the default to be set to finding these.

Some keyboard shortcut changes. The GUI is so radically different, so this is excusable. For the most part, things are the same.

Get iPhone programming tips in your inbox with my Beginner iPhone Programming Tips newsletter.