Rick Minerich's Development Wonderland : algorithms

F# Discoveries This Week 07/16/2010

RickM — Fri, 16 Jul 2010 15:49:19 GMT

As promised, a fresh batch of links to sooth your aching desire for more F#. I’m particularly excited to announce I’ll give giving a F# tutorial this year at the Commercial Users of Functional Programming conference. CUFP is going to have a lot of great content this year and will be well worth attending for anyone interested in functional programming.

News

FAKE – F# Make 1.40.5.0 Released

F# Jobs at Credit Suisse, London

I’ll be giving a F# tutorial at CUFP

Video

Steffen Forkmann speaks on F# Open Source Tools at the New England F# User Group

Presented at the New England F# User Group on June 7, 2010, Steffen discusses FAKE and NaturalSpec. Steffen is the author of the two open source F# projects "FAKE - F# Make" and "NaturalSpec".

Articles

Alex Pedenko’s Introducing Furious – A proof-of-concept RRM for F#

Meet furious. Furious is a RRM - a Record Relation Mapping system. It is a database-independent object query dsl for records, that currently has a (barebones) mysql implementation. Here's how it works. Suppose you have a record graph like so…

Vagif Abilov’s Exploring Amazon S3 with F#

The purpose of this article is to show how fast you can dig into low level details of an unknown technology using F#, and how little code you need to write. Therefore I keep the text of the article short, focusing just on the required steps.

Yin Zhu’s F# Async workflow application: a Flickr crawler

My strategy is to use the search query to search images with some specific tags and from the result page(as shown below), the url of each image is extracted, from which the image and its tags are then crawled.

Daniel Markham’s F# Versus Microsoft's Regex. A Lesson in Types

I was doing some text processing. As part of that, I set up a few RegExes. As I continued coding, I realized that I was following a pattern: apply the regex, check the match count, and if there were a bunch of matches, either get the first or last item.

Jon Harrop’s F# vs Mathematica: an even faster pricer for American options

This new optimized and parallelized F# solution is now a whopping 960× faster than the original Mathematica code from Sal Mangano's Mathematica Cookbook.

Neil Carrier’s Pure OOP – A Personal Retrospective

Almost instantly, my thoughts about the problem undergo a phase change, and I re-write my earlier code to be more succinct, maintainable, and composable, and usually more computationally efficient.

Neil Carrier’s Integer Square Roots

This is an old algorithm, once popular in assembly language programs on small processors. The fact that it uses only integers, addition, subtraction, and less-than branching, mean that its hardware and software requirements are at rock bottom.

Julien Ortin’s F# Event module extension

Functions to extend the F# Event module.

Julien Ortin’s Socket helpers in F#

This post describes a module to perform common socket operations using asynchronous operations and reactive programming.

Julien Ortin’s European Central Bank – extracting reference rates with F#

Every day, the European Central Bank publishes “official” reference FX (foreign exchange) rates where currencies are quoted against the Euro (expressed as EUR/XXX), or 1 EUR = xxx XXX. The exchange rates of the last thirty sessions are available in xml format which we shall try to parse. In order to do so, we use F# and active patterns, based on Don Syme’s draft paper.

Petr Lepilov’s F# interactive, AppFabric cache and PowerShell Part 1 and Part 2

Applications can store any serializable CLR object without worrying about where the object gets stored. Scalability can be achieved by simply adding more computers on demand. The cache also allows for copies of data to be stored across the cluster, thus protecting data against failures. It runs as a service accessed over the network.

Steve Gilham’s dotcover 1.0 beta – first impressions

Not having R# at home -- because I rarely use C# even if I'm writing for .net -- it's this which interested me more. So, I gave it a try on my current F# project

Kurt Schelfthout’s F# and Code Contracts: not quite there yet

In this post I’ll show how you can get Code Contracts sort of working for F#. From my very initial explorations, I would conclude that they seem basically usable for F# programming – but you’ll need some glue and tape, and not everything works as you’d expect.

Edmon Begoli’s Scala vs. F#, Application Programming Features Round 1 and Round 2

F# and Scala, two relatively recent programming languages, provide most .NET and Java software developers with new functional programming features that are worth understanding and evaluating.

Ivan Towlson’s F# pattern matching for beginners, Part 1, Part 2 and Part 3

Pattern matching provides a concise but clear and highly expressive way of writing conditional logic, because it combines the conditional flow with the ability to extract values of interest

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 12/29/2009

RickM — Tue, 29 Dec 2009 16:45:42 GMT

It’s been a bit of a light week with the holidays. Although, for the truly dedicated, that’s just a chance to get some quality time in with with a favorite programming language (or to write a poem about it).

Tomas Petricek uses Accelerator in a GPU Game of Life simulation

This article is the second one from a series about using Accelerator from F#. Today, we'll use Accelerator types directly from F# - this is the simplest possible approach and is very similar to the way you'd work with Accelerator in C#.

Robert Sundström explores GCD and LCM in F#

I have spent this evening composing some mathematical functions in F#. So far I have just made two for gcd and lcm and one that can identify prime numbers. I want like to share the code with you.

Robert Pickering describes his work on FunctionalNHibernate

In the future I’ll be looking at how to broadening what you can do with FunctionalNHibernate ClassMap descriptions and improve data access by integrating Linq like features.

Flying Frog solves Rosetta Code’s Data Munging 2 Example

Perhaps the most surprising result is that the F# solutions are extremely concise even when compared with bleeding-edge research languages such as Haskell.

Flying Frog plays with Generic Algorithms

The program begins with a random string of letters and spawns a generation of 200 random mutations of the parent string, selects the fittest mutation (by similarity to an "ideal" string) and uses that individual to spawn the next generation. The ideal string used is "METHINKS IT IS LIKE A WEASEL".

Julien Ortin uses F# to clean up his temporary internet files

A quick and dirty F# script to clean temporary internet files (including Flash cookies which don’t get deleted by the browsers).

Steffen Forkmann observes asynchronous downloads with Rx and F#

This time I will demonstrate how we can use this API and asynchronous workflows to download a couple of websites asynchronous and in parallel.

The PFX Team tours the .NET 4 Parallel Programming Samples

On Code Gallery, we have a plethora of samples that highlight aspects of the .NET Framework 4 that help with writing scalable and efficient parallel applications. This post examines each of those samples, providing an overview of what each provides.

Satnam Singh writes a poem about F#

Distracted by Abstraction - A poem about F#

Steepest Ascent Hill Climbing in C# and F#

RickM — Mon, 28 Dec 2009 19:21:09 GMT

Recently I’ve been working with some local search techniques and wanted to share my Steepest Ascent Hill Climbing solution.

The general idea of Steepest Ascent Hill Climbing is that in each iteration of the hill climbing process you apply a set of transforms to your input data and select the best result via a fitness function. This result, or the transform which created it, is then the input for your next iteration. The process stops when no transform in an iteration scored higher than the previous generation’s winner.

In this way each iterative step brings you closer to a local maxima of your fitness function’s graph. This is where the term “Hill Climbing” comes from. It is considered a relatively simple AI technique but is also is broadly applicable, quite easy to reason about and can be tweaked for many different corner cases.

For this particular example we will be assuming composable transforms. For each iteration of our hill climbing we will apply our standard transform set to the winning transform of the last round and so produce a new set of transforms.

public delegate T TransformComposer<T>(T lastT, T thisT);
 public delegate S TransformApplier<S, T>(S set, T transform);
 public delegate uint FitnessFunction<S>(S set);
 
 public class HillClimberResult<S, T>
 {
     public HillClimberResult(uint score, T transform, S set)
     {
         Score = score;
         Transform = transform;
         Set = set;
     }
 
     public uint Score { get; private set; }
     public T Transform { get; private set; }
     public S Set { get; private set; }
 }
 
 public class HillClimber<S, T>
 {
     public HillClimber(
       TransformComposer<T> composer,
       TransformApplier<S, T> applier,
       FitnessFunction<S> fitness)
     {
         TransformComposer = composer;
         TransformApplier = applier;
         FitnessFunction = fitness;
         Transforms = new List<T>();
     }
 
     public List<T> Transforms { get; private set; }
 
     private TransformComposer<T> TransformComposer { get; set; }
     private TransformApplier<S, T> TransformApplier { get; set; }
     private FitnessFunction<S> FitnessFunction { get; set; }
 
     public HillClimberResult<S, T> FindMaxima(S inputSet, T initialTransform)
     {
         if (inputSet == null)
             throw new ArgumentNullException("inputSet");
         if (initialTransform == null)
             throw new ArgumentNullException("initialTransform");
         if (Transforms.Count == 0)
             throw new ArgumentException("No transforms were set.");
 
         HillClimberResult<S, T> best;
         HillClimberResult<S, T> iterBest = ApplyTransformAndScore(inputSet, initialTransform);
 
         do
         {
             best = iterBest;
             foreach (T transform in Transforms)
             {
                 var nextTransform = TransformComposer(best.Transform, transform);
                 var result = ApplyTransformAndScore(inputSet, nextTransform);
                 if (iterBest.Score < result.Score)
                     iterBest = result;
             }
         } while (iterBest.Score > best.Score);
 
         return best;
     }
 
     private HillClimberResult<S, T> ApplyTransformAndScore(S inputSet, T transform)
     {
         var transformedSet = TransformApplier(inputSet, transform);
         var score = FitnessFunction(transformedSet);
         return new HillClimberResult<S, T>(score, transform, transformedSet);
     }
 }

I like the way this worked out in C# quite a lot. However, take a moment to compare it to a F# version I quickly whipped up:

type HillClimber(composer, applier, fitness, transforms) =
     member x.FindMaxima initialSet initialTransform =
         let maxOfScores one two = if fst one > fst two then one else two
         let findBestTransform set lastTransform =
           transforms
             |> List.map (fun(transform) -> composer lastTransform transform)
             |> List.map (fun(transform) -> applier set transform, transform)
             |> List.map (fun(transformedSet, transform) -> (fitness transformedSet), transform)
             |> List.reduce maxOfScores
         let rec climb set lastScore lastTransform =
             let (thisScore, thisTransform) = findBestTransform set lastTransform
             if thisScore <= lastScore then (lastScore, lastTransform)
             else climb set thisScore thisTransform
         climb initialSet (fitness initialSet) initialTransform

It’s quite shocking how much less code is necessary. However, there is a small problem with this example. As we are not using HillClimber from inside of its own library, all of its function inputs resolve to System.Object. The solution is to simply do a bit of annotating to ensure that compile time types are as generic as possible.

type TransformComposer<'t> = 't -> 't -> 't
 type TransformApplier<'s,'t> = 's -> 't -> 's
 type FitnessFunction<'s> = 's -> float
   
 type HillClimber<'s,'t>(composer: TransformComposer<'t>, applier: TransformApplier<'s,'t>, fitness: FitnessFunction<'s>, transforms: list<'t>) =
     member x.FindMaxima initialSet initialTransform =
         let maxOfScores one two = if fst one > fst two then one else two
         let findBestTransform set lastTransform =
           transforms
             |> List.map (fun(transform) -> composer lastTransform transform)
             |> List.map (fun(transform) -> applier set transform, transform)
             |> List.map (fun(transformedSet, transform) -> (fitness transformedSet), transform)
             |> List.reduce maxOfScores
         let rec climb set lastScore lastTransform =
             let (thisScore, thisTransform) = findBestTransform set lastTransform
             if thisScore <= lastScore then (lastScore, lastTransform)
             else climb set thisScore thisTransform
         climb initialSet (fitness initialSet) initialTransform

Of course, it would be great if the F# type system would reduce to generics instead of System.Object in this case. I would think the ideal would be to always reduce to the most generic type possible. I’ll have to give it a try tonight with the latest VS2010 beta and see if there is any improvement.

Continuing on, let’s give this a go with something simple. We know that the maximum value of |A| – A^2 is 0.5, –0.5. Can we climb our way to one of these values?

#load "HillClimber.fs"
 open HillClimber
 
 let composer last next = fun x -> (last x) + (next x)
 let applier set transform = transform set;
 let fitness x = abs( x ) - (x ** 2.0)
 let transforms = [fun x -> x + 1.0; 
                   fun x -> x - 1.0;
                   fun x -> x + 0.1;
                   fun x -> x - 0.1;
                   fun x -> x + 0.01;
                   fun x -> x - 0.01]
 
 let climber = new HillClimber<float,float->float>(composer, applier, fitness, transforms)
 
 let initialValue = 0.0
 let (score, transform) = climber.FindMaxima initialValue (fun x -> x)
 let result = transform initialValue

…Highlight, Alt-Enter…

val composer : ('a -> float) -> ('a -> float) -> 'a -> float
 val applier : 'a -> ('a -> 'b) -> 'b
 val fitness : float -> float
 val transforms : (float -> float) list =
   [<fun:transforms@10>; <fun:transforms@11-1>; <fun:transforms@12-2>;
    <fun:transforms@13-3>; <fun:transforms@14-4>; <fun:transforms@15-5>]
 val climber : HillClimber.HillClimber<float,(float -> float)>
 val initialValue : float = 0.0
 val transform : (float -> float)
 val score : float = 0.25
 val result : float = -0.5

Looks good!

Well, it looks like that took a bit longer than I had anticipated. I’ll be back with my weekly update tomorrow.

Discoveries This Week 02/06/2009

RickM — Fri, 06 Feb 2009 16:24:00 GMT

Some interesting gems this week. Revit, Closures and MathTools won the day. However, I do hope you'll take a look at the IL post as well.

Blog – Jeremy Tammik’s Use F# Directly in Revit

In Jeremy’s post he discusses what is initially necessary to get F# and Revit working together. He also provides a sample of a Revit addin written in F#.

Revit is Autodesk’s architecture and design studio. It allows physical engineers to coordinate and play with, design and visualize data while integrating directly with AutoCad. It also provides a .NET 2.0 API. Given F#’s support for units as well as it’s concise and mathy style, it makes sense that it would be an ideal language for engineers.

Site - WikiBooks FSharp Programming

Before I stumbled upon this site, I had never head of of WikiBooks. That’s why I was incredibly surprised to find that it has the best online general F# reference around. It has extensive sections on functional, immutable and imperative programming with rich examples and references to the math behind the ideas presented. It’s a great site to have at hand for both those learning about the language and those experienced but still needing to occasionally look something small up.

StackOverflow - A practical example of a closure in F#

Learning how to program functionally is much more than just learning some new ideas and a new syntax. It comes along with a ton of new jargon, some of which can be quite foreign sounding. I find that it often turns out that the jargon actually represents a very simple idea and that becomes immediately obvious when discussed with a simple example.

Software – FSharp.MathTools

As you might have suspected by its name, MathTools is an extensive set of mathematics libraries for F#. It provides, among other things, statistical functions, fast fourier transforms, optimization algorithms, Matlab compatibility and extended mathematical notation. With a little development this combined with VSLab could provide a viable alternative to tools like Matlab while still allowing for collaboration with colleagues.

Article – Introduction to IL Assembly Language

It’s the responsibility of any serious programmer to know how how his or her tools work all the way down the chain. In this relatively short article (given the topic) everything you would need to write a .NET compiler is distilled. It’s the best reference of it’s kind I’ve seen.

Discoveries This Week 01/16/2009

RickM — Fri, 16 Jan 2009 16:17:00 GMT

This week’s theme is functional programming. Included are discussions on Software Transactional Memory, Functional Architecture and the impact of the CLR on functional Programming in .NET.

Blog: Brandon Werner’s Software Transactional Memory: Debunked!

In starting with a title that is decidedly sensationalistic, Brandon effectively trashes STM over its expensive overhead based on a paper published by ACM. His position, and that of the researchers, is that most programmers see assignment as inexpensive and so would not understand that they need to optimize for atomic transactions when using STM.

Brian Hurt responded at length in his blog post The Problem with STM: your languages still suck. Brian’s view is that the fundamental issue here is that most programming languages encourage heavy use of mutable variables and so many expensive assignments and reads are happening when STM is used. If instead one is using a functional programming language which discourages variable mutations, the high cost of STM is much less of an issue. Brian then further flushes out his ideas in a follow up blog in which he responds to responses to his first.

While I don’t agree that ACM’s analysis “puts a deep nail in the coffin of STM”, I also don’t think it’s reasonable to expect most programmers will be jumping on the functional programming bandwagon in the near future. The main issue is that it’s just too different from what they are used to.

For now FP will remain the domain of the motivated and pragmatic programmer. It will be necessary to slowly ease the majority into this new, different world via things like functional C# extensions. I do think that some kind of STM with training wheels for mainstream programmers would be a good way to promote this over the long term. However, it would be extremely important that the inherent overhead is explicitly stated.

Finally, I wanted to note that Sasha Dadiomov of the Microsoft STM team has an interesting piece on the difficulties involved in debugging STM. It’s an informative glimpse of how Microsoft’s implementation of STM is shaping up.

Blog: Chris Smith’s Speech Recognition is gun [sic] and easy!

It’s possible he meant fun and easy but I can’t be sure.

A quick but fun piece on leveraging System.Speech.Dll inside of F#. The result is a 10 line program that takes your speech as input and prints it to the console. Very simple yet quite cool.

Blog: Matthew Podwysocki’s How would the CLR Be Different?

In this post Matthew discusses how the CLR might be better implemented to serve the needs of functional programming languages. I especially like the idea of including some new functionality for type manipulation and construction.

However, I would like to see specific examples of exactly what Matthew would like changed under the hood. He mentions a lot of general goals with reasoning to back them up but not how they might be implemented. I also feel that it would be inappropriate to implement some of these ideas at the CLR level instead of the language or API level.

For example, non-null references. I’m all for Spec# style pre and post conditions but why is it necessary that this be implemented at the CLR level? This belongs in the language instead. Also, the issue with immutability in .NET mostly has to do with Microsoft’s .NET API design. The stack based nature of IL is completely compatible with the idea.

The CLR should be designed with the most general case in mind and not with the slant towards any particular language. If the CLR is to be viable long term, flexibility must be emphasized over specific optimizations.

Paper: Sebastiaan Visser’s Building a Wiki in Haskell

A study on implementing a Wiki in Haskell which is a purely functional programming language. This paper is a must read for both those interested in functional project architecture and those who question the viability of using FP for large applications. The complete source of the project is available for your viewing pleasure.

Discoveries This Week 01/09/2008

RickM — Fri, 09 Jan 2009 16:37:00 GMT

It’s been a very exciting week. I actually had more things to post than time would allow me to write about. I’ll have to save them for next time. Blog: Daniel Spiewak’s What is Hindley-Milner? (and why is it cool?) Hindley-Milner is the algorithm all...(read more)

Discoveries This Week 12/26/08

RickM — Fri, 26 Dec 2008 20:22:55 GMT

Being the holiday season, it’s been a bit of a slow week. Still, I stumbled across some very good articles and sites I would like to share. I also wanted to note that I will be tagging all of my “Discoveries This Week” posts with the roundup tag for easy filtering.

Blog: Steve Sounders’s State of Performance 2008

In this blog Steve provides an excellent overview of developments in web browser performance over the last year and then ventures to predict what may be coming in 2009. I’m not sure I agree with all of his predictions. For example, Think “Web 2.0” would be heavily dependant on framework development. However, I would agree that the next generation of web pages will require fast Javascript engines and so there will be quite a lot of pressure for browser developers to keep up. Surely this is what Google is betting on as Chrome is the leader in fast Javascript. Still, until Chrome gets a real plugin interface and some skinning, it will never be able to eat into Firefox’s market share.

The most interesting piece of information I gleaned from this article is that Google is going to be taking page loading time into account when determining the quality score used in Adwords. I can only wonder how they plan on doing this in both an impartial and game resistant way. Will a bigger data pipe or distributed servers mean cheaper Adwords? Only time will tell.

Series: Steve Apiki’s Managing Multi-Core Projects Parts 1, 2, 3, 4, 5, and 6

This series covers the process of mutli-core enterprise development at many different levels. Building a capable team, defining the development processes and architecture decisions are all discussed to some degree. As these were posted in quick succession, I haven’t yet had the time to thoroughly read through any but the first in the series. However, the first article was excellent and so I would expect that they all share the same high degree of quality.

Site: Collected Algorithms

This site contains a huge number of different math algorithms taken from ACM-published computer science papers. The archive ranges from papers submitted in 1960 to today and claims to only provide algorithms has the properties of “originality, accuracy, robustness, completeness, portability, and lasting value”. References are also provided and so if you wish to understand see the algorithm in context, the option to go look up the corresponding paper is available to you. While the license is noncommercial use only, ACM is open to relicensing and so it may be still worth taking a look if you have a particularly difficult problem that needs solving.

Software: Debug Inspector

Debug Inspector is a free addin for both Visual Studio 2005 and 2008 which provides a set of tools to help with mutli-threaded debugging. This includes (but is not limited to) browsing the callstack of multiple threads at the same time, automatic deadlock detection and .NET integration. If I had this back when I was working on parallelizing our image commands it would have saved me a great deal of time. I haven’t had a good chance to put it through it’s paces yet but the reviews have all been fantastic. I suggest checking it out if it suits your needs. A small walkthrough is available here.