1-2-3 example

Create a website in Visual Studio (I’ve taken a MVC one here) and right-click on your project, go to the Nuget package manager and search for ‘Processing.js’ in the online section

Click on ‘Install’ and a couple of JS libraries will be added to your Scripts folder.

Either in your aspx/html or in the ‘_layout.cshtml’ file add a reference to the ‘Processing.js’ library. You can simply drag-drop the file from the Solution Browser into the text editor and Visual Studio will automatically create the correct reference. From this point on the possibilities are endless, have a look at the Processing ehibition for instance.

For example, if you wish to add a clock to your page change the ‘Index.cshtml’ to the following:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

@{
    ViewBag.Title = "Home Page";
}
<h2>
    A simple processing.js clock
</h2>
<p>
    <canvas id="canvas1" width="200" height="200">
    </canvas></p>
<script id="script1" type="text/javascript">
 
    // Simple way to attach js code to the canvas is by using a function
    function sketchProc(processing) {
        // Override draw function, by default it will be called 60 times per second
        processing.draw = function () {
            // determine center and max clock arm length
            var centerX = processing.width / 2, centerY = processing.height / 2;
            var maxArmLength = Math.min(centerX, centerY);
 
            function drawArm(position, lengthScale, weight) {
                processing.strokeWeight(weight);
                processing.line(centerX, centerY,
        centerX + Math.sin(position * 2 * Math.PI) * lengthScale * maxArmLength,
        centerY - Math.cos(position * 2 * Math.PI) * lengthScale * maxArmLength);
            }
 
            // erase background
            processing.background(224);
 
            var now = new Date();
 
            // Moving hours arm by small increments
            var hoursPosition = (now.getHours() % 12 + now.getMinutes() / 60) / 12;
            drawArm(hoursPosition, 0.5, 5);
 
            // Moving minutes arm by small increments
            var minutesPosition = (now.getMinutes() + now.getSeconds() / 60) / 60;
            drawArm(minutesPosition, 0.80, 3);
 
            // Moving hour arm by second increments
            var secondsPosition = now.getSeconds() / 60;
            drawArm(secondsPosition, 0.90, 1);
        };
 
    }
 
    var canvas = document.getElementById("canvas1");
    // attaching the sketchProc function to the canvas
    var p = new Processing(canvas, sketchProc);
    // p.exit(); to detach it
</script>
<div style="height: 0px; width: 0px; overflow: hidden;">
</div>

Run/display this page and you’ll get something like the following:

The Value of Data Visualization from Column Five on Vimeo.

Finding the needle in the haystack is now more pressing than before. The more data we produce and have access to, the more the need for something intelligent to get the information out of the data becomes important. Obviously the ever-increasing amount of data and the shift to global data stores like the cloud have increased the need for better visualizations techniques and innovative thinking.But the amount of noise has also increased and the need to choose through it. How to filter out of the billions of tweets the stuff that matters to you? The only way to do that is by choosing; what matters to you is related to the things that you choose for and which have a direct relevance in your life (personal or professional). Before the filtering comes the criteria and the criteria are dictated by the business or personal context combined with a more-or-less precise definition of what the solution or answer should be like. Usually a question has many answers or complementary answers, much like a mathematical problem has a one or more solutions depending on the target space within which the solution should be found.

Although I find it refreshing to see that data visualization and presentation techniques are now more important than ever before, it’s not for myself the reason why this field is interesting or fertile. Data visualization is useful as a product for the end-user or consumer but is equally well interesting for the producer or creative inventor because it combines various fields. Like nothing else you need to be partly an artist, partly a scientist to come up with something beautiful yet meaningful and interesting. You need to understand sometimes deep technical details and exotic programming concepts while having a good understanding of the business context and what a customer needs. You need to fathom the (business) question and at the same time have a vision, which usually means a mixture of intuition and expertise. You need to understand the language of different people and sub-cultures, read through minor details, yet see through the details and go beyond to deliver a broad concept. Having a bird’s-eye view while knowing the murky details on a low-level demands a mind which can stretch across all levels of thinking. Can you make the simple complex and the complex simple? Can you see color where others see mathematical formula’s? Can you see sound where others see data and shapes? Can you see code where someone sees motion? Can you see patterns where others see noise? Can you see information where others see data?

• Visualizing.org
• Information is beautiful
• Data Visualization Showcase

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

type Node =
    int (* node identifier *) *
    'TDaton (* node data *)
 
type Connection<'TDaton> =
    int (* source Id *) *
    int (* sink Id *) *
    int (* weight *) *
    'TDaton (* connection data *)
 
type Adjacency<'TDaton> =
    Connection<'TDaton> list (* a list of connections to other nodes*)
 
type Atom<'TNodeDaton, 'TConnectionDaton> =
    Node<'TNodeDaton> * Adjacency<'TConnectionDaton>
 
type Graph<'TNodeDaton, 'TConnectionDaton> =
    Atom<'TNodeDaton, 'TConnectionDaton> list

The connections are directed links between nodes and the weight tuple factor is taken out of the generic data bucket in order to make weighted graph analysis possible. One could replace the generic data attached to the connection by an interface which would require a weight property, but here again this would complicate things in code. In any case, in the documentation of the library I have added an example of how to attach polymorphic data buckets to nodes and connections.

The adjacency type is just an alias for a connection list and, finally, the graph is as advertised above just a list of nodes with their adjacency list. The Atom type is a type alias for one single graph (list) element and comes handy in the algorithms.

From these few type definitions you can spend the rest of your life doing graph analysis and implementing all the known (or unknown) graph algorithms; shortest path, Hamiltionian cycles, connected components and so on. At this point the current implementation contains the most used ones and the emphasis was also on having a quick (and easy) way to display the graph (and their properties).

Obviously, if you want to implement some graph algorithms you need all the basics like; adding nodes, removing connections, setting node data, fetching upstream and downstream nodes, testing whether a link exists and so on. In addition, you also need a way to easily create graphs or generate random graphs (with a fixed node degree for example). Since most of the graph analysis focuses on paths and structure it’s often not necessary to adorn the graph with data or weights, hence the possibility to define graphs through a more simple structure:

1
2
3
4
5
6
7
8
9
10

 
let pregraph =
        [
        (1, [2]);
        (2, [3;5]);
        (3, [4]);
        (5, [4]);
        ]
let graph = Orbifold.FGraph.ParseList pregraph
graph |> GraphVisualizer.Show

This will launch the visualizer and produce the following simple graph:

The power of F# resides in the handling of lists and avoiding loops as one would in C# tremendously helps in situations like this. One should compare the ParseList method implementation with what it would take in C#:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

///<summary>Parses a simple list made out of tuples of (int, int list). The first integer is the index and the list is the list of nodes indices to which the current node is connected.</summary>
let ParseList (list : (int* int list) list) : Graph<Object,Object>=
        let g = ref Graph.Empty
        let linkedIds: int list ref = ref []
        let containsNumber number list = List.exists (fun elem -> elem = number) list
        g.Value <- (list |> List.map (fun (idx,adjs) ->
                                let newNode : Node<Object> = (idx, null)
                                let ad = List.map (fun t->
                                                        if not (containsNumber t !linkedIds) then linkedIds.Value<- t::!linkedIds
                                                        let con : Connection<Object> = (idx,t,0,null)
                                                        con
                                                   ) adjs
                                let atom : Atom<Object,Object> = (newNode,ad)
                                atom
                          ))
        (*we auto-add the node if it appears in the connections*)
        linkedIds.Value |> List.iter (fun t ->
                                             if not (NodeExists t !g) then
                                                            let n : Node<Object> = (t,null)
                                                            let c : Adjacency<Object> = []
                                                            g.Value<-(n,c)::!g
                                      )
        g.Value

The interesting part of the library sits in the analysis module where one encounters the unavoidable traversals and where I tried to also implement useful variants like the depth-first traversal of edges:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

let DFTEdgeVisit (g:Graph<_,_>) (start:int) (processEdge: int*int->unit) =
        let nextToVisit = Stack<int>()
        let discovered = HashSet<int>()
        let v = ref 0 (* current vertex *)
        ignore(nextToVisit.Push(start))
        ignore(discovered.Add(start))
        let parents = Dictionary<int,int>()
        while nextToVisit.Count > 0 do
            v.Value <- nextToVisit.Pop()
            if parents.ContainsKey(!v) then processEdge (parents.[!v],!v)
            let someDescendants = GetDescendants !v g
            match someDescendants with
            |None -> ()
            |Some(desc)-> List.iter (fun d -> if not (discovered.Contains(fst d)) then
                                                                                    ignore(parents.Add(fst d,!v))
                                                                                    ignore(discovered.Add(fst d))
                                                                                    ignore(nextToVisit.Push(fst d))) (List.rev desc)

Here again, one would use in C# Action<> parameters for the visitors but in F# things are made easy since functions and variables are on the same footing.

Some of the algorithms, like the shortest path between two nodes, are quite straightforward in C# but are really an headache when trying to convert to purely functional analogs. At this points the library does its best to honour the functional paradigm (also because often it represents immense performance gains w.r.t. the more linear non-functional versions) but sometimes the traditional algorithms are more readable and hence more accessible for developers who wish to alter the code.

Finally, I’d like to highlight the graph visualization part which resides in a separate library. When experimenting with F# and graphs in the F# interactive mode you can easily display the graph by feeding it to the GraphVisualizer.Show method:

1
2
3
4
5
6
7
8
9

let g =
        [
        (1, [2]);
        (2, [3;5]);
        (3, [4]);
        (5, [4]);
        ]
g |> GraphVisualizer.Show;;
GraphVisualizer.ShowShortestPath(1,4,g) ;;

You can also use the graph visualizer as a WPF component in your application. The control is a classic MVVM control with an ItemsSource accepting a Graph structure. Typically you’d use it as follows:

1

    <Visualizer:GraphControl x:Name="Diagram" Grid.Row="1" Tension="{Binding Value, ElementName=TensionSlider}" ItemsSource="{Binding Graph}"/>

where the tension determines the tension between the node in the spring-embedder layout algorithm. I’ll add some more layout algorithms in the next pass (tree layout variations in particular).

The WPF component also has easy access to the analysis like for example the shortes path:

1
2
3
4
5
6
7
8
9
10
11
12
13

let g2 = Graph.ParseList [
                            (1, [3;6;9]);
                            (2, [4]);
                            (3, [2;5]);
                            (5, [20]);
                            (6, [7;8]);
                            (7, [12]);
                            (9, [10;11]);
                            (12, [13]);
                            (20, [12]);
 
                        ]
this.Graph <- Graph.Analysis.ColorizeShortestPath( 1,13, g2)

where “this.Graph” is here the MVVM property of the model bound to the GraphControl. The result would be the picture below.

Some final remarks and questions regarding this project:

• all’s F#; the custom diagramming control, the library and the MVVM stuff. It would make sense to use this library in a C# context (to benefit from the F# performance) but I haven’t put any energy in this. Not sure it’s a priority since our other libraries (G2, Lynx) contain all this as well.
• this is work in progress and I spend a lot of time documenting things as well as creating sample code, I reckon things will settle by September this year.
• making this open source would be a good thing for the community but I’ll have to sleep over it. You can try to convince me.
• the WPF control is a templated control and can be customized. On the other hand, the arrow and node visual are hard coded. It could be useful to template them as well and in this fashion enable databinding of the databuckets defined above to the visuals. However, this library is not a full-fledged Visio replacement, rather it focuses on graph analysis. Does is make sense to invent a mechanism to enable more line-of-business scenario’s? I think our existing graph libraries are filling the need there. The only reason I would put energy in this is that at this moment there is no graph visualization library for F# on the market.
• What about Silverlight? Well, I don’t see a technical issue there but I am less sure about the audience doing Silverlight development in F#. Is there an audience for this?

Thanks to Tomas Petricek for some useful suggestions and the Flying Frog for insightful directions.

• is a computational expression the same as a workflow, is it a monad?
• how do math articles about monads map to articles about functional programming?
• are the methods defined by F# as part of a computation expression dictated by the idea of a monad? How to translate the concepts from categories to functional programming and back?
• why should I care about monads, they never appear in C# or JavaScript…!?
• how can the Haskell or OCaml stuff be translated to F#? Though Haskell has a whole lot of info regarding monads, it’s not always easy to see how it maps to the F# syntax or way of thinking.

Let me say straight away that understanding monads will not directly solve your marketing challenges, nor will it make writing software easier, not is it a magical recipe to simplify the data access layer of your website. However, it does

• make you a better programmer in the same way that learning design patterns (anti-pattern etc.) teaches you to recognize structures and solutions on a higher level of abstraction
• shed light on the relationship between domains which seem unrelated (exception handling, state management, graphs and networks, asynchronous calls, domain specific languages and so on)
• suggest you to rethink software structures and how typical programming challenges are solved
• open up a large field of ideas in the overlap of software development and maths which are fun to explore.

I don’t expect to see monadic stuff appear in Silverlight animations or in CSS style sheets but for sure you’ll see it appear in

• the NoSQL movement and graph analysis algorithms
• the financial and insurance business where F# is at this moment a big hit
• DSL developments and meta-programming

and who knows what the future brings?

A simple idea

We are surrounded by data collections and structures, sets of interrelated data and hierarchies:

• a family and its members where relationships are defined by concepts like father, mother, sister, uncle and so on
• company hierarchies with employees and relationships defined by team structures, divisions and so on
• modules of code and calling/instantiation relations where exceptions are bubbling from down the stack to the upper (UI level if not properly handled) parts
• algorithmic financial transactions (flows) based on some intricate logic

and on a more scientific level even more where one notices certain similarities and intriguing analogies:

• genes and memes: the formation of genetic structures vs. the formation of thoughts and ideas
• the spreading of viral diseases vs. the spreading of computer viruses
• the six-degrees of freedom appearing on the internet vs. the plex of actors in the IMDB database

In a lot of cases similarities are just accidental (it’s because a banana and a lemon are yellow that there is deep connection, except the shared pigment) but there are equally well amazing symmetries which can be made precise. Category theory is a theory which makes this idea of ‘being similar’ exact and at the heart of it is really a very simple notion:

• you have collection of objects
• a collection has a certain structure
• you can map objects from one collection to another and the relationship can also be mapped.

From this we take a bold step a define a (pedestrian) category as follows (more precise definition below):

Maybe it should be called at this point a pedestrian category or something because this is of course not very precise; this definition would turn pretty much everything into categories and functors! At this point I only want to help you understand where the real maths and the hard F# stuff is coming from and make it more acceptable.

A morphism is something which morphs one thing into another, something which transfers one thing into another. You will also encounter in the literature similar concepts like

• homomorphism: it emphasizes even more the idea of morphing. The prefix ‘homo’ meaning ‘the same’ and ‘morph’ means ‘changing’. Technically speaking the term homomorphism comes from group theory and morphism refers to the more general idea which can be applied outside group theory and Lie groups.
• endomorphism: ‘endo’ means ‘in itself’ and this emphasizes that a morphism is not going somewhere else but stays in the same package. So, an endomorphism of a family would map one person onto another inside the same family. A morphism would in general morph one family onto another.
• epimorphism: here the emphasis is on the fact that the morphism reaches the whole target collection.
• isomorphism: in this case the morphism is mapping elements one-to-one and onto the target. The notion is a very important one and appears pretty much everywhere in maths and science. In essence it says that if two things are isomorphic they are indistinguishable from one another and anything.everything you say about one is valid for the other.

Some more simple examples

In order to move away from the heuristics above towards some more serious definitions I need to highlight more (simple) examples.

Example

Take the real number (floats, if you prefer) with an operation called ‘addition’. Take the same real number with an operation called ‘multiplication’. We call them objects in the category of ‘real numbers with an operation’. A morphism f between the two objects is This morphism has the amazing property that: and this property is shared with many other types of collections. In addition, you should also notice that zero is mapped to one and that zero is the identity (null element) for the addition while the number one is the identity for the multiplication.

Example

Take the collection of lists of strings (List in C# and ‘string List’ in F#) and consider the morphism called ‘concatenation’ between lists. Take the collection of lists of integers on the other hand and with the same concatenation of of lists as with the string collection. A functor here is the List.map operation of F# and you should note that it doesn’t matter whether you concatenate things first and then apply the map or first apply the map and then concatenate things. In a mathematical fashion you can write that if F is the List.map action and f, g are morphisms then

Some simple list manipulations

There are some well-know examples of categories and monads like the so-called maybe monad, the identity monad and the state monad but I think the easiest way to explore or check the ideas is by means of the concat monad over the category of lists of integers, called from here on List (in bold). It consists of the following:

• sets and subsets of integers: [], [1], [1;2;3], [[1], [5;6]]…are examples of objects in this category
• the return operation which returns a singleton set from any given element
  
• the identity operator which returns whatever is given:
  
• the concatenation operator which concatenates list:
  

Now, you can play with these operations and discover some interesting properties like the fact that:

Property

Indeed if you take an arbitrary set, say [[[a];[b]];[[c;d];[[f]]], an apply the left hand side you get:

The other side of the equation tells you that:

In a similar fashion you can show that

Property

Now, let’s introduce a *-operator which acts on morphisms f in the List category:

This star-operator has also some interesting features which immediately generalize to arbitrary monads later on, namely:

Property

All these things are really easy to show inside this List category but have a deeper meaning on a general level.

Some simple maths

At this point you are ready to receive the general definition of a category and a monad.

The only difference here with the pedestrian definition above is that morphism need to satisfy the associative constraint and the existence of an identity.

Definition
A functor is a map F from one category to another which maps both objects and morphisms in such a way that

At this point you should see how this abstract definition corresponds to the various examples above, in particular the List category in the previous section. In the literature you will also see that the collection of morphisms between two objects A and B is denoted by Hom(A,B), which is an abbreviation for ‘Hom-omorphisms’.

In the previous section you was that the List category of integers has some interesting features when you combine the (List.map), the return, the id and the concat operations. The general definition of a monad is simply expressing the fact that many structures have the same set of properties. Let me first rephrase it in this specific category;

The List category has

• an operation (actually an endofunctor) (List.map) which maps lists onto lists
• the return operation creates a singleton from an element
• the concat operation together with the return operation has the following properties:
  

and this turns the triple (List.map, return, concat) into a monad.

In general, a monad is a triple which satisfies the same set of properties and you’ll see instead of concat and return the following:

Don’t be scared away by all this, it’s just an abstract reformulation of the simple concatenation and mappings of lists above! I do need however to push things a bit further because the way a monad is defined in maths is in general not the way you’ll recognize it in F# or Haskell. Usually you’ll see the equivalent formulation by Heinrich Kleisli who invented the Kleisli triple and which turned out to be an equivalent definition for monads. That is, it can be shown that there is a one-to-one correspondence between a Kleisli structure and a monad.

and you should immediately recognize the properties we mentioned above in the context of the List category. The proof that the two definitions are leading to the same structure is not difficult but it wouldn’t be useful at this point (unless you are math oriented and you need to see it to understand it).

Some simple F#

The prototypical example in the context of F# workflows is the ‘dividing by zero’ problem; one cannot divide by zero. If you have a computation where at some point an exception is raised (either explicitly or by the runtime) it doesn’t make sense to continue a computation but maybe you want to handle the exception.
The way to handle this in F# is by using a label attached to a number; if the label says ‘failure’ it doesn’t matter what the value is, if the label says ‘success’ it makes sense to read the value. It’s a way to include infinity in the constraint range of values the runtime can handle:

1

type Result = Success of float | Infinite

Next, instead of the usual division you define a divide function like so

1
2
3
4

let divide x y =
  match y with
  | 0.0 -> Infinite
  | _ -> Success(x/y)

and plug it into a class with two members:

1
2
3
4
5
6

type SaveDivision() =
 member this Bind ((x:Results), (res: float->Result))
  match x with
  |Success(x) -> rest x
  | Infinite -> Infinite
 member this.Return x = x

At this point you can look at this as a class with two methods but what you really should see is that

• the map from a float number to the Result type is an amplifier or lift map as we described in the example above; it’s the endofunctor on the Net category of data types
• the Bind operation corresponds to the *-operation of a Kleisli triple
• the return corresponds to the eta-mapping of the Kleisli triple

and it turns this triple into a monad! You should also reflect on the fact that the Bind member correspond to the concat operation on the List category (and similarly the return corresponds to the return member).

The way you use the SaveDivision monad in a concrete computation is by instantiating it and do something inside as follows:

1
2
3
4
5
6
7

let safe = SaveDivision()
let SomeCalculation x1 x2 =
 safe {
    let! x = divide 1 x1
    let! y = divide 1 x2
    return divide x y
 }

and as soon as you try this on zero you get the Infinite as an answer. Without this construction you would get an exception, obviously.The ‘bang’ or exclamation mark after the let keywords is actually a way to tell F# that the Bind operation should be used instead of the normal assignment (or type inference).

So, this very simple example highlights the following:

• monads in F# allows you to do ‘stuff’ under the hood and redefine how things are being assigned or returned
• a monad in F# is really a Kleisli triple but because it’s mathematically equivalent to a monad there is no need to differentiate. I does confuse however when you try to compare the mathematical textbooks with the functional programming textbooks
• monads are often called workflows because it allows you do embed a whole logic or workflow inside the instantiated class (monad) and redefine how things like the assignment (let!) should function. You will also see that F# in fact has extended the notion of monad to include other monad members and in this fashion allowing you to redefine how for-next, try, yield and other statements are acting inside the monad.
• monads are sometimes called computation expression since it redefines how assignments and expressions should act on (category) objects

In Haskell you will not encounter the alternative names and the term monad is used uniformly.

The suspicious mind should by now worry about a lack of consistency and feel the need for more formal proofs that for example the constraints (or defining rules) of a Kleisli triple (aka monad) are satisfied. Indeed, is the SafeDivision monad with the specified operations satisfying the constraints? Well, yes, it does. But I will refrain to reproduce the proofs and am happy to forward you to someone you tediously wrote it all down; see Paul Abraham’s blog and this document in particular wherein you’ll find the F# proofs.

A simple dictionary

In Haskell the following type class is used to implement monads:

1
2
3

class Monad m where
   return :: a →m a
   (>>=) :: m a →(a →m b) →m b

You can immediately recognize the return and the bind methods but the symbol ‘>>=’ is usually used instead of ‘bind’. Purists will tell you that the discussion around monads in Haskell is not complete without the topic of ‘comonads’ and ‘cofunctors’ but it will take a while before these discussions appear in the F# community. See this article in case you want to know more about this.

In order to use monads in F# you only need to implement an (implicit) class which implements the Bind and Return member. The language extends the purely mathematical definition with eight extra methods:

Finally, the following table should be helpful in case you wish to move back and forth between F#, Haskell and the math literature.

Haskell	F#	Math
return	return
>>==	bind	* operator
instantiate the Monad type class	implement at least the Return and Bind members	NA
Monad	Monad, Monad Expression, Workflow, Computation Expression	Monad with an equivalent definition through Kleisli triple. The defining structure in F# and Haskell is really a Kleisli triple but no distinction is made there between the two types.
NA	NA
functor through a type class definition	usually not mentioned	functor
function	function (‘fun’)	morphism
Hask category of Haskell data types	Net category of data types	a wild zoo of categories; groups, topologies, graphs, differential geometries, quantum field theories and so on
composable functions	composable functions	binary operation and monoids

References

• F# monad library
• Haskell wiki
• Haskell category theory on Wikibooks
• F# programming on Wikibooks
• Try F#; awesome online F# learning site
• nLab on everything categories in mathematical physics

SharePoint Workspace was unable to interpret the SharePoint location. Please check and ensure the location contains no typing errors.

The solution to this consists in adding a public facing URL and making sure the server has remote differential compression installed/enabled.

Go to Server Manager > Features and take a look at whether the remote differential compression is enabled. If not, check and install.

Next go to SharePoint Central Administration > Alternate Access Mappings and click the ‘Edit public URL’ . Once there, make sure that besides the default internal URL there is also a public facing URL through which users can sync via the Workspace application.

Like most issues in SharePoint, fairly simple to fix but often a whole research before figuring out what is going on.

Recently a customer requested a particle simulation with the intention to investigate correlations and the effect of multiple ‘attractors’. The real, underlying issue in this demand is the fact that certain situations and systems are governed by laws (differential equations) which cannot be solved exactly and require a dynamic system to search for critical coefficients. These coefficients result in (semi) stable configurations or highlight boundary conditions inside which things make sense.

The problem with these kind of systems is the scalability which has two aspects; the visualization which doesn’t scale well with the retained graphics pipeline of WPF/SL/WP7 on the one hand  and the O(N*N) calculation of interactions between particles.

Regarding the visuals there is really a lot to consider:

• if you inherit from a baseclass like FrameworkElement or Control or even UserControl you carry around with each and every particle a whole lot of stuff; data binding, styling, event and other infrastructure. While all these things are really great in an LOB, one doesn’t usually need all this when dealing with (lots of) particles
• typically the underlying surface needs to be a Canvas but this element also brings along many gears; the retained rendering system, the measure/layout mechanics, styling and more. Maybe the bonus you miss when bypassing the Canvas is the ability to easily integrate zoom and pan in an application.
• how much user-interaction is required, are mouse-events necessary or is it a ‘let it run’ system? Here as well, you need to consider carefully the implications (especially related to the scalability of the app).

With respect to the simulation or calculation part things are more straightforward but you also need to think about

• the possibility to use F# for the more mathematically oriented parts. The disadvantage is however the need to constraint your model to make sure things talk to C#, or you have to go the full nine yards in F# (talking to XAML is still a disaster in this case).
• how to optimize the calculations and to make sure that inside loops you break early and branch as much as possible
• dropping unnecessary properties of the particles and make the particle system as lightweight as possible

Within the Silverlight/WP context my experience is that if you use the Canvas/UIElement combination you easily hit a wall around 500 particles due to the way the rendering engine is functioning and the fact that the UIElement (or FrameworkElement) are too ‘heavy’. The inter-particle calculation will still run OK with 500 particles but the end-result is that it’s not a good solution altogether.

One can keep the Canvas as underlying surface and render particles as inherited Shape items but this doesn’t push the boundary much.

A step further is to replace the Canvas with a bitmap and use direct pixel printing. This is easily done with the WriteableBitmapEx project you can find on CodePlex. This boosts your rendering to 5000 particles if you drop interactions. However, if you switch on inter-particle forces you hit a calculational wall around 1500 particles which is still way better than the retained rendering solution but still somewhat underwhelming.

So, as a next step it would be great to use parallel processing for the algorithmic part but unfortunately there is no task parallel processing library (TPL) for Silverlight (though somewhat made an unofficial port). Another possibility would be to use MailboxProcessor of F# but it would entail threading issues and an altogether more difficult system.

Various samples and libraries are available for XNA and Windows Phone which allow one to create particle effects but

• the often use sprites or similar techniques to minimize the particle count. The results are usually very good but the aim in the context of games is usually to create a certain effect rather than to give a physically correct simulation.
• they often do not exhibit inter-particle forces. If they do the particle count is low.
• they focus on effects and not physics

See also the Flint-sharp library which is a port of the Flash/Flex library.

The conclusion is that one can perform simulations and develop particle system in Silverlight if the need is not above, say, a thousand particles. Above this threshold things become more difficult and Silverlight as a medium becomes less suitable for this type of task. Obviously there are high-tech solutions on the basis of C++ and GPU instructions but this was outside my client’s scope (and my technical know-how as well).

Note: on different level you need to note in the attached simulation sample that

• the average speed varies a lot while the amount of interacting particles stays the same
• the ergodic phenomenon if easily shown; that the average velocity over the sample equals the average of one item in time
• it’s quite difficult to create stable configurations; which mimics well how the real world is also constantly influenced by quantum fluctuations

References

• TPL library ported to Silverlight 4
• Particle system for games (XNA & WP)
• Flint for C#
• WriteableBitmapEx on CodePlex

Most probably, if you receive this error you also will get it when opening the SQL Server Configuration tool with a message stating

It seems this happens when you run a 64bit version of SQL Server and have removed a 32bit one earlier. Both versions share the same WMI configuration and, hence, things get lost when uninstalling some stuff. In this Microsoft Support report you can find some background where the essential bit is:

mofcomp “%programfiles(x86)%\Microsoft\Microsoft SQL Server\100\Shared\sqlmgmproviderxpsp2up.mof”

(run this in an elevated  CMD) as well as reconfiguring the server to enable file streaming.

EXEC sp_configure filestream_access_level, 1
RECONFIGURE

(run this as a SQL query).

Lo and behold, if you go through this you can move on and use SQL Server WMI again. If you’re curious about mofcomp, it’s the managed object format compiler parser but very little info is available about this tool and it seems to me that it’s one of those things (like the registry) you better handle with silk gloves.

To resolve this simply drill down into the following  series of screens

Central Administration > Application Management > Manage Service Applications > Business Data Connectivity Service > Your data screen > Set Permissions

Add the administrator to the permissions and you can thereafter happily enjoy data from BCS!

Each business has its own needs and criteria but from this side the following criteria were important:

• customization: API quality, documentation, programming language and support. A system like Sitecore is for sure the max but there is also a steep learning curve. On the other side of the scale, there are thousands of interesting CMS system with poor API or documentation.
• availability of plugins. WordPress has a practically endless amount of plugins while SiteFinity is a bit thin in this respect.
• choice of themes and skins. Here again, a system like SharePoint seems an all-rounder but assigning a brand to a site is, well, a project on its own.
• ease of deployment and setup requirements. A great systems requires a great environment, whether in terms of security or in terms of cost, one cannot avoid administrative issues (aka requirements) with larger CMS systems.
• costs This one is relative, of course.
• integrations: can the system integrate with other systems (billing, PM, mail…)?
• maintenance effort With the ubiquitous HTML5 wave and JavaScript madness one has to be prepared for changes. How does a CMS system evolve in an ever changing IT landscape?

There is also the fact that

• if you have used a CMS before you probably have already a database full of content; can this content be transferred to another system and what does it take?
• each system has a certain workflow or mechanics which one gets used to. Changing CMS means changing habits and rethinking e.g. the categorization (ontology) of the content delivery.
• look-and-feel is to some extend bound to the underlying site logic. A theme from WordPress is not necessarily easily transferred to SiteFinity or vice versa.

On a technical level there are obviously also certain aspects to consider like; .Net or PHP or Ruby, MySQL or SQL Server, WCF enabled or XML-RPC…?

So, choosing a CMS is really a project on its own and when chosen the real hard work is ahead; customization, content (re)formatting and so on. In as far as this small company is representative for you, our considerations were the following:

• we have used WordPress in the past seven years and fully satisfied with it. Content transfer and upgrade is reduced to nill in this case.
• there are tons of themes, plugins, community articles and site using WordPress. Whatever you are looking for, someone already made it and WordPress has an easy plugin system to adorn your site to your taste with these themes and plugins.
• cost and deployment are small. No need for high-end servers or special administrative priviledges.
• it’s PHP and MySQL (though you have SQL Server and Azure solutions) but the learning curve is smooth. In fact, PHP is fun and MySQL is a wonderful RDBMS.
• the biggest issue is integrations and the possibility to mix-match things with either home-made systems or third-party system. This is our compromise.

This said, systems like SiteFinity or Orchard are really a joy and well worth a look. It just depends what you need and your business context.

Together with this site update it was time to rethink the way accounting was functioning, how contracts and licenses were kept up to date, how customers could download updates and more. All of this sounds simple and straightforward but the effort it took to make it happen was surprisingly heavy. Maybe not so much a technical challenge than a conceptual challenge. Among other things, the aims was:

• to enable customers to log into the system, see their licenses, download updates, view previously sent invoices, view their SVN credentials and more
• to replace our existing (and costly) CRM system with a more home-made and custom system
• to keep track of flavors, versions and prices of our products
• to create a base for a more elaborate software tracking system

Indeed, how to make sure that an address which has been used in an invoice cannot be altered subsequently (but at the same time allowing a customer address to be changed of course)? How to design a database for multiple products, each having various flavors and all having potentially different prices? At the same time, we deliver more consulting services than really being a product-selling company, so the whole invoicing system had to be flexible in this sense as well. On the one hand this whole conceptual design process was challenging and required trial and error, on the other hand it was a lot of fun.

Not the least the fun of developing this project came from the fact that the entity framework 4.1 has this code-first features which allows one to develop things initially in a very organic fashion. I emphasize ‘initially’ here since code-first is not good practice for larger and more enterprise-level software. Additionally, the ASP.Net MVC3 framework brought back the fun in developing websites. It’s just a great joy to use Razor and one cannot deny that with respect to webforms the razor approach makes one so much more productive.