planet wmassdevs articles

F# Discoveries This Week 02/25/2010

Between Atalasoft, Professional F# 2.0 and the MVP Summit I’ve been completely swamped and ended up with quite a backlog of posts. Between the Brian-Chris F# Code Battle, Luca’s LChart, Ashley’s continuing FScheme series and Matthew’s MongoDB stuff I’m not sure I can pick a favorite. That’s not true, I’d go right for the DAWG-fight series. The arcane secrets of F# optimization await inside.

C9 Lectures: Dr. Don Syme - Introduction to F#, 3 of 3

In Part 3 of this 3-part lecture series, Dr. Don Syme elaborates further on: Patterns, Object Basics, [and] Imperative Programming.

Dr. Don Syme’s Async and Parallel Design Patterns in F#: Agents

In part 3 of this series, we explore lightweight, reactive agents in F# and look at some typical design patterns associated with these agents, including isolated internal state.

Chris Smith’s DAWG-fight, Optimizing text search in F# II and Dr. Brian McNamara’s DAWG-Gone (F# Language Team Code Battle Summary)

So today I’ll walk you through what Chris did right (shortest… subsection… ever!), as well as what he did wrong (get comfy in your chair), and then show my own implementation.

Luca Bolognese’s LChart: Displaying Charts in F# Parts One, Two and Three

I want to use F# as a exploratory data analysis language (like R). But I don’t know how to get the same nice graphic capabilities. So I decided to create them. Here is a library to draw charts in F#.

Dr. Brian McNamara’s An RSS Dashboard in F# Parts Four, Five and Six.

You can see from the colors in the screenshot from part one what I desired, but this requires knowing which links are ‘visited’ and which are not, so I can color each link appropriately. It turns out, this information can be had via unusual means…

Ashley Feniello’s FScheme Parts Ten and Eleven

We’re now taking the first small step into the world of nondeterministic logic programming (chapter 16 of Bill Hails’ book). Hopefully you enjoyed the last post about continuation passing and found the idea to be ripe with potential power; indeed so powerful that we’re going to use it now to bifurcate the universe! No really, we are…

Luca Bolognese’s A simpler F# MailboxProcessor

I always forget the pattern to use to create a functioning MailboxProcessor in F#. I mean, which piece has to be async and how to structure the recursive loop. When I find myself in that kind of a situation situation, my instincts scream at me: “Wrap it and make it work how your mind expects it to work”. So here is a simplification of the paradigm.

Matthew Podwysocki’s The F# PowerPack Released on CodePlex

As announced yesterday, the new February 2010 release of F# is out. This release is much more of a stabilization release instead of adding a lot of features including improvements in tooling, the project system and so on.

Matthew Podwysocki’s Exploring MongoDB with F#

I just want a quick answer with the data I have. There was one issue of course that nagged me which was the ubiquitous use of strings for everything from databases, collections, and keys. With a language such as F#, could we do any better than this approach?

Matthew Podwysocki’s F# and the Dynamic Lookup Operator ala C#

In the F# language, we have the ability to define two “dynamic” operators, a get member operator denoted by the ( ? ), and the set member operator denoted by the ( ?<- ). The F# language and its associated libraries do not have an actual implementation of these operators, but instead allow you to implement them as you see fit.

Steve Gilham’s Updating F# posts to 1.9.9.9 Parts One and Two

Possibly a few more issues will come out as I reconstitute my analysis tool, which is currently undergoing a retooling of its build system to automate some of the manual checks for whether the operational tests succeeded or not.

Steffen Forkmann’s FAKE – F# Make 0.29 Released

Last week I released version 0.29 of my build automation tool “FAKE – F# Make”. The new version comes along with a couple of changes which I will now describe.

Luis Diego Fallas’s Using a Webcam with DirectShowNET and F#

In this post I'm going to show a small F# example of using DirectShowNET to access a webcam and manipulate the image data.

Mark Needham’s F#: Passing an argument to a member constraint

I've written previously about function overloading in F# and my struggles working out how to do it and last week I came across the concept of inline functions and statically resolved parameters as a potential way to solve that problem.

Julien Ortin’s BitTorrent Bencoded values and BitTorrent Metainfo file handling in F#

Byte strings can be strings represented as byte strings (such as the description of the exchanged data), as well as an array of bytes (such as a hash). Representing them with the .Net strings can thus lead to errors. Hence we shall keep the byte array representation.

Julien Ortin continues his series on Purely Functional Data Structures with a Skew binomal heap, a Banker’s double-ended queue, a Alternative binary random access list, a Bootstrapped queue, and a Implicit queue.

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

Scott Seely’s F# is Changing My Style

The types I’m interested are concrete (no abstract methods) and have a zero-argument constructor. 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:

Steve Gilham’s It almost feels like cheating…

Having renamed all the .c files as .cpp, getting a first building assembly was simple, and then making it refer to an initially empty F# library, no problem; and then setting up an (again, initially empty) unit test assembly depending on both (where vice-tests to match up new and old implementations, and their eventual unit test replacements can accumulate), just as normal.

Brad Clow’s F# Examples talk at BFG

Earlier this week I gave a short talk at the Brisbane Functional Group on F#. The idea was to give an introductory feel for the language by way of some simple examples.

Phillip Trelford’s F# Talk at Edge UG: Slides and Demos

I presented a 1 hour talk introducing F# with 4 demos (attached to this post): Full-screen WPF POS Checkout sample with Barcode scanner integration (in 100 lines). Twitter WPF client script (200 lines). Matermind board game in WPF (300 lines). Lunar Lander XNA game (>400 lines).

Matt Jackson’s AssertWasCalled in F# (or how I learned to stop worrying and hate extension methods)

Unfortunately, this upcasting led me on a short goose chase to find out which interface in the Rhino Mocks codebase was responsible for AssertWasCalled only to realise that it was an extension method sitting hiding away somewhere else.

Get Started with F# via Higher order IEnumerable extension methods in C#

The more I use F# the more I want to write my every day production C# code in a functional way. To this end, I’ve written a few higher order extension methods as the need arose. I wanted to take a moment and share them with you. I think that in seeing an implementation of these functions in C#, what they do becomes easy to understand.

Filter provides a new collection with unwanted items removed.

public static IEnumerable<T> Filter<T>(this IEnumerable<T> list, Predicate<T> predicate)
 {
     List<T> newList = new List<T>();
     foreach (var item in list)
     {
         if (predicate(item))
             newList.Add(item);
     }
     return newList;
 }

Reduce boils down a collection into exactly one item of the collection’s containing type.

public static T Reduce<T>(this IEnumerable<T> list, Func<T, T, T> function)
 {
     var enumerator = list.GetEnumerator();
     enumerator.MoveNext();
     var last = enumerator.Current;
     while (enumerator.MoveNext())
     {
         last = function(enumerator.Current, last);
     }
     return last;
 }

Fold is much like reduce except that it boils the collection down into an instance of any type.

public static U Fold<T, U>(this IEnumerable<T> list, Func<T, U, U> function, U initial)
 {
     var enumerator = list.GetEnumerator();
     var last = initial;
     while (enumerator.MoveNext())
     {
         last = function(enumerator.Current, last);
     }
     return last;
 }

Map takes one collection and returns another of the same length by applying a function to each element.

public static IEnumerable<U> Map<T, U>(this IEnumerable<T> list, Func<T, U> mapFunction)
 {
     List<U> newList = new List<U>();
     foreach (var element in list)
     {
         newList.Add(mapFunction(element));
     }
     return newList;
 }

While these four are a good subset to begin with, F# provides a much broader range of IEnumerable functionality. Also, while examples here build new lists, their F# counterparts often evaluate lazily and so are usable with very large, parallelized or even infinite sequences.

For a more detailed view with some F# and Linq code check out Matthew Podwysocki’s post on learning Functional C# from F# and LINQ. His example are actually lazy when appropriate and have precondition checks.

Get Started with F# with Higher order IEnumerable extension methods in C#

Filter provides a new collection with unwanted items removed.

public static IEnumerable<T> Filter<T>(this IEnumerable<T> list, Predicate<T> predicate)
 {
     List<T> newList = new List<T>();
     foreach (var item in list)
     {
         if (predicate(item))
             newList.Add(item);
     }
     return newList;
 }

Reduce boils down a collection into exactly one item of the collection’s containing type.

internal static T Reduce<T>(this IEnumerable<T> list, Func<T, T, T> function)
 {
     var enumerator = list.GetEnumerator();
     enumerator.MoveNext();
     var last = enumerator.Current;
     while (enumerator.MoveNext())
     {
         last = function(enumerator.Current, last);
     }
     return last;
 }

Fold is much like reduce except that it boils the collection down into an instance of any type.

internal static U Fold<T, U>(this IEnumerable<T> list, Func<T, U, U> function, U initial)
 {
     var enumerator = list.GetEnumerator();
     var last = initial;
     while(enumerator.MoveNext())
     {
         last = function(enumerator.Current, last);
     }
     return last;
 }

Map takes one collection and returns another of the same length by applying a function to each element.

internal static IEnumerable<U> Map<T, U>(this IEnumerable<T> list, Func<T, U> mapFunction)
 {
     List<U> newList = new List<U>();
     foreach (var element in list)
     {
         newList.Add(mapFunction(element));
     }
     return newList;
 }

Amazon KDK Beta Program is Open for Applications

Amazon has opened their KDK Beta program. Amazon also published a KDK FAQ. As suspected, it’s Java ME based with a custom API for the Kindle:

[It will] provide UI components, JSON and XML parsers, HTTP and HTTPS networking, secure storage, and other features. Other APIs like audio and dictionary access will be available in a future release of the KDK.

Development will be possible in an Java environment, but it appears that Eclipse will be supported more directly.

F# Discoveries This Week 02/08/2010

Back again with another F# community roundup. There’s been a ton of great content this week, almost too much. To try to combat this I’ve attempted to sort posts roughly in terms of how interesting I found them. All were worth the read though.

Also, I’ll be speaking this Wednesday on F# at the Boston .NET User Group. If you find yourself there, be sure to say hello!

Don Syme’s Introduction to F# (Video 1 of 3)

Dr. Don Syme is a principal researcher in MSR Cambridge. He has a rich history in programming language research, design, and implementation (C# generics being one of his most recognized implementations), and is the principle creator of F#.

Ashley Feniello’s FScheme Part 8: Language vs. Library

Perhaps this post should have gone along with the one about macros and how Lisp is a “programmable programming language.” The common tension in any language or runtime design is how much to build in as primitives and how much to implement as libraries within the language or atop the runtime.

Luke Hoban’s F# for Parallel and Asynchronous Programming

Last November at PDC 2009 in Los Angeles I gave a talk on F# for Parallel and Asynchronous Programming. The talk begins by covering basic F# concepts, and then focuses on four challenging issues related to concurrency and the tools F# brings for addressing these - immutability, async workflows, and agents.

Andrew Brehaut’s On Iteration (Could just as well be entitled “Why Programmers Leave Python/C#/Java")

There is an observable trend in Python programmers that results in a reasonable section of them moving to functional programming languages. This trend is encouraged by the Python language, and has a couple of temporal considerations.

Matthew Podwysocki’s Using and Abusing the F# Dynamic Lookup Operator

Much like C# 4.0 has the ability to do dynamic lookup, F# also has the same capability, although in a different capacity. The language has support for a dynamic lookup get operator ( ? ) and set operator ( ?<- ), but note that I said support and not actual implementation. The actual implementation is up to you and how you want to use it.

Matthew Podwysocki’s A Kick in the Monads – Writer Edition

In the past couple of Monads posts, we’ve talked briefly about the State and Reader Monads and their potential uses and misuses. Before this series completes, I have a few more to cover including the Writer, Continuation and eventually Observable monad. Today, we’ll get started looking at the Writer Monad and what it can do for us.

Ashley Feniello’s Recursion Is the New Iteration

Not all recursive expressions represent recursive behavior. In fact, iteration can be expressed recursively. One trick when considering the process that an expression represents is to think of functions as reducing to values rather than returning them. In a pure functional style (precisely because of referential transparency) you can do analysis by successive substitution.

Julien Ortin continues his series on Purely Functional Data Structures with a Real-time double-ended queue, a Skew binary random access list and a Binary random access list

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

Flying Frog Consultancy Presents - John Conway’s Game of Life in 32 lines of F#

John Conway's Game of Life is a famous example of a simple cellular automaton that produces remarkably diverse results. The game can be implemented in only 32 lines of F# including real-time visualization using Windows Presentation Foundation as follows:

Brian McNamara’s An RSS Dashboard in F# (Part 3)

Last time I covered IObservables and we created a useful ObservableSource class. Today I’ll cover the next technology piece of the app: reading RSS feeds. I’ll discuss the design considerations regarding how to poll feed for updates and publish feed items as IObservables, and walk through one implementation.

Nick Gravelyn’s Pong in F# with XNA Game Studio

A few of my colleagues were discussing F# today and when/where/how it is/isn’t better than C#. I haven’t ever really used F# beyond a very, very brief look at the syntax, so tonight I decided to see what it was all about. As a little project, I decided to make Pong with XNA Game Studio using F# with Visual Studio 2010.

Jim Burger’s Maybe F# isn’t for you…

If you aren’t excited about new ways to tackle the concurrency problem, or new approaches to handling generic and mathematical problems, and if the thought of breaking out the shiny new lexer and parser don’t give you a tingle, then maybe F# isn’t actually marketed at you at all.

Alex Turner’s Calling F# from COBOL and Back Again (CodeProject)

Running languages on .NET is ultra-powerful. Using managed COBOL (from Micro Focus), it is possible to use F# code to work with COBOL code. Imagine a Cloud based F# map reduce system consuming legacy COBOL - yes, that really is on the horizon.

Steffen Forkmann’s New syntactic sugar for “FAKE – F# Make”

The new version 0.27 of “FAKE – F# Make” comes with new syntactic sugar for build targets and build dependencies. Don’t be afraid the old version is still supported – all scripts should still work with the new version.

Jared Parsons’s Having fun with events in F#

Recently I ran into a situation where I needed to handle some events in F# in a special way. In this particular case I wanted to be able to disable and re-enable my handler based on changes in the program. Essentially the C# equivalent of continually adding and removing the handlers.

Steve Gilham’s “Hello Glade#” from F#

Another bit of spiking, a rather tardy follow up from raw GTK#, starting from the C# example at the Mono Project site, but incorporating the earlier example, so as to build in a clean application exit, for one thing.

Luis Diego Fallas’s Using a Webcam with WIA and F#

In this post I'm going to show a small example of taking a picture using a Webcam with Windows Image Adquisition 1.0 . This API seems to have changed in Vista and above, the following code only applies to XP.

Flying Frog Consultancy’s WPF Tic-tac-toe demo

The article walks through the design and implementation of a multithreaded program that uses logic programming to create an unbeatable computer opponent and Windows Presentation Foundation to provide a graphical user interface in only 115 lines of elegant F# code!

A (Relatively Reasonable) Discussion of F# on Slashdot

OCatenac passes along an interview with Don Syme, chief designer of F#, which is Microsoft Research's offering for functional programming on the .Net platform. Like Scala, which we discussed last fall, F# aims at being an optimal blend of functional and object-oriented languages.

What the iPad needs to be your only computer

There’s been a lot of talk about how the iPad will be used by people that aren’t experts in computers. This article makes a good case that Grandmas and Technophobes will love the iPad:

The darndest thing happened in the last five days and I was fortunate to be privy to it. Apple has gotten people excited about computing. But this time, it’s not nerds or geeks and certainly not IT industry analysts. It’s everyone else. I had a curious set of three conversations this week. One with a grandma, one with a technophobe and the third with a self-proclaimed luddite.

And this article explains the difference in computing habits between the Gen Xers that came of age during the PC revolution and the generation before and after us.

The reason I’m starting to think the Old World is ultimately doomed is because we are bracketed on both sides by the New World, and those people being born today, post-iPhone and post-iPad, will never know (and probably not care) about how things used to work. Just as nobody today cares about floppies, and nobody has to care about manual transmissions if they don’t want to.

Both of these articles make a great case, and although, I need a regular computer to do development, I would like everything else to migrate to an iPad.

I started to use Macs again after ten years when I got a digital camera. I read the instructions for the Windows software it came with and then just plugged it into a Mac I inherited -- it just worked. Since then, I’ve used a Mac for everything except my job (.NET SDK development).

Which brings me to my first problem with the iPad -- how do I connect my digital camera? Steve Jobs talked about how great the iPad would be for photos, but how do they get on the iPad to begin with? Undoubtedly, this will be solved, but it’s a problem that will make the iPad useless for a lot of people if this is their only computer.

Secondly, I don’t take a lot of pictures and almost no video and I have about 10-15 GB of photos (and 20-25 GB of music). 64 GB is just completely inadequate if this is going to be the only place to store them. For the iPhone, synching gives me downsampled photos and music if I want to save space, but I can’t do that to my primary copy. I’m sure iPads will get to bigger sizes, but I’m also sure that we’ll need more too.

Even if the iPad had a terabyte, I really need some off device storage -- iPads can be lost, which would be bad, but not as bad as losing all of my data. It’s unclear how the iPad can be backed up if it’s your only computer.

I know that these problems will be solved eventually, but right now -- it’s not really possible for the iPad to work without a host computer -- if it’s like the iPhone, it depends on synching too much.

I’m not sure what the solution will be, but I have a Time Capsule -- if the iPad had Time Machine, and if the Time Capsule could suck the images off my digital camera (perhaps using the iPad as the UI), then I’d be most of the way there.

Array.prototype.toString

This is one of my favorite javascript tricks, because of its effort-to-payoff ratio.

Problem: the default Array.prototype.toString hides any nested structure.

[1, 2, 3, 4, 5].toString(); //-> "1, 2, 3, 4, 5"
[1, 2, [3, 4], 5].toString(); //-> "1, 2, 3, 4, 5"

Solution: override Array.prototype.toString.

Array.prototype.toString = function() {
    return '[' + this.join(', ') + ']';
};

[1, 2, 3, 4, 5].toString(); //-> "[1, 2, 3, 4, 5]"
[1, 2, [3, 4], 5].toString(); //-> "[1, 2, [3, 4], 5]"

How the iPad will affect the Kindle

Amazon has no hope of competing with Apple to be the best general computing tablet platform, so trying to match the iPad feature for feature will drive up their cost and still leave them with an inferior product. The two other stable competitive positions are either to go cheap or to go niche.

In his 1980 classic Competitive Strategy: Techniques for Analysing Industries and Competitors, Porter simplifies the scheme by reducing it down to the three best strategies. They are cost leadership, differentiation, and market segmentation (or focus). Market segmentation is narrow in scope while both cost leadership and differentiation are relatively broad in market scope.

This will be hard for Amazon because, before the iPad, they were clearly the differentiated premium market-leader, but now that market has been subsumed. The only hope for Kindle is to become the cost-leader and to let third-party developers turn the Kindle into cheap niche devices.

Once the KDK is available, we’ll see the top end come down to about $400. Amazon can do this because they’re set to make money from their free 3G, in the form of subscription applications. I’m sure a significant component of the $489 price is to offset the expected 3G use that isn’t offset by book sales.

This strategy is more in line with Amazon’s online retail strategy. They currently compete on price and let third-party stores focus on niche markets. Even though Porter cautions against trying to have two strategies, it can be overcome if different business units focus on each strategy independently -- what could be more independent than a third-party.

F# Discoveries This Week 01/29/2010

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:”

Hoping the Amazon KDK is Java based

The speculation on the KDK is that it’s going to be Java based, and I hope that’s right. We know for sure that it runs Linux, and that there’s a JVM and obfuscated jars on the device. According to what I’ve read, there’s no perl or python or anything like that on it, so the only options will be C/C++ or Java. For the sake of the ecosystem, Amazon will need to pick Java and probably will run third-party code in a some kind of sandboxed environment.

To me the best thing about it being Java based is that I will finally have a JVM that I care about targeting. One of my big problems with Java is that there’s no place the JVM runs where something else doesn’t run better or that I just like more. For web apps, I prefer python based frameworks, and for Windows apps, you have to use .NET or Win32 with C/C++. On a Mac, Objective C is the obvious choice. Java is a good choice on a lot of mobile devices, but I haven’t cared about them, until now.

And the main reason I want a JVM to target is because it gives me a practical reason to use clojure. I know it might not work out, and of course, I’ll be writing Java at first to learn the API, but I’m hoping I can transition to clojure eventually, or at least use a hybrid.

In 2008, Rich Hickey came to speak in Northampton, and I prepared by learning and blogging about clojure for the 20 days preceding it. Since then, I’ve been on a lookout for a JVM that I wanted to target. The closest I’ve come is the Google AppEngine, but I still liked python and Django style better. It may turn out that the KDK just works better with Java, but clojure has shown that it’s pretty good at driving OO frameworks like Swing, so I think it will work just fine.