Earlier this week at the Mix10 conference, Microsoft announced the developer story of the Windows Phone 7 Series. As expected, it’s all about Silverlight! For all the details I highly recommend to watch the recorded keynotes (day 1, day 2).

Tonight I could resist trying to build my very first Windows Phone 7 application; the traditional Hello World thingy. Because the developer tools (Visual Studio 2010 and the free Visual Studio 2010 Express) have pretty nice templates, that wasn’t much of a challenge. So I tried to build something real: an application that can display SharePoint 2010 content, for example items from an announcements list. I head to work my way around some limitations because both SharePoint 2010 and the developer tools are still in beta and CTP, but finally I got it working! Because of the many workarounds, the code is not yet ready for publication, but I’ve created a small screencast so you can see the result. To be continued! :-)

Windows Phone 7 POC: Getting SharePoint Data from Jan Tielens on Vimeo.

The Microsoft Azure Cloud is looking pretty solid compared to just a few months ago.  The storage mechanisms in the cloud now are blobs, drives, tables, and queues.  Also, not to forget, is SQL Azure.  I won?t dive too much into that, as most will know what SQL Server is, and SQL Azure is pretty much just a hosted SQL Server instance.

The blobs are generally geared toward holding binary type data, images and those types of things.  The tables are huge key value type stores.  The drives are VHD, which are virtual hard drives.  The queues are just queues used for workflow and also to store messages back and forth in a queue.

These methods are accessible via REST, which makes application development against the storage services extremely easy.  This is a big plus point as REST services are a preferred way to connect and interact with data storage.  It also sets up Silverlight as a prime framework to utilize services.

Day 4 I pretty much dedicated to reviewing these cloud services and finishing up work related development.  With that, I'm wrapping up my MIX 2010 blog coverage.  Now back to your regularly scheduled programming.

Rearchitected from the ground up

• Hardware Architecture
• Capacitive touch – 4 or more contact points
• Sensors
• GPS
• Accelerometers
• Compass
• Light
• Proxmity
• Camera
• Multimedia
• Memory
• GPU
• CPU
• Only 2 resolutions
• Software Architecture
• Built on WinCE
• MS is writing almost all of the device drivers instead of OEM
• App updating, Licensing built in
• New UI model
• Shell frame
• Direct3D
• XBox LIVE, Bing, Location, Push notifications
• Apps all built on CLR (no unmanaged code)
• Silverlight, XNA, HTMl/JavaScript
• Frameworks built for you to access all phone features
• App Model
• What is an app?
• Uniquely identifiable and servicable product packaged as XAP
• Application deployment
• Windows phone marketplace
• Application license
• Crypto-verifable object issued to grant rights to the applications
• Phone only installs .xap pakcages signed by marketplace
• phone handles all aspects of .xap installation based on manifest
• you cannot make arbitrary changes to the phone during install
• Users control install, update and uninstall, while the marketplace controls revocation
• Phone only runs apps that have a valid marketplace license
• Apps are sandboxed into separate security accounts while installed and at runtime
• Resource allocation policy keeps the foreground app responsive
• Resource management policy ensures the user can always use Start to run an app.
• App hosting
• Each app executes inside an isolated, least-privileged host process
• all app code is transparent and CLS-verifiable
• Frameworks enable app code to interact with app model, UI model, phone functionality
• Frameworks
• CLR
• Silverlight
• Device & phone
• Cloud
• UI Model
• Concepts
• Application – UI and logic for functionality exposed through pages
• Page  a single screen of user interaction elements
• Session – An ordered workflow of user interactions spanning applications
• UI metaphor – Web
• Sessions can be paged out when inactive.
• Page State – Contains data that describes an instance of a page, analogous to browser cookie
• Allows the phone to discard all UI info when app is inactive
• Rehydrates page ui based on Page State info
• Graphics composition
• Each page gets it’s own layer on top of the Direct3D  surface
• Cloud Integration Services
• built-in user experiences and APIs
• Familar APIs for interactingwith existing web 2.0 services
• Rich support for incorporating custom web services
• Location Service
• support for consuming GPS, AGPS and Wi-Fi based location
• reverse geo-coding
• Push notification service
• Managed APIs for notification-driven interaction
• When battery is low the service may shut down
• This is not guaranteed message delivery.
• Based on the state of the phone, message could be delayed, batched, or dropped.
• Gamer Services APIs

One of my many (almost) daily tasks when working on the CodePlex platform since releasing Mercurial as a supported version control system, is converting projects from Team Foundation Server (TFS) to Mercurial. I'm happy to say that of all the conversions I have done since mid-January, the success rate of migrating full source history is about 95%. To get to this success point, I have had to learn and refine several techniques utilizing a few different tools… (read more)

I would like to thank everyone who came out to last night’s event and especially thank Mike Vogt for the presentation.

I think at first everyone glassed over since very few of us spend a lot of time with Integration Architecture and most of us live more in the application architecture space.  Learning about subject like BPEL and BPMN was refreshing.

The discussion after Mike’s talk was lively and I think that everyone came away with a good idea of areas they might want to know more about.  People stuck around long after the meeting was over.

If you are interested in the topic you can find the slides here.

Be sure to join us next month when Matt Hidinger talks about Onion Architecture.  Details are coming soon.

Last Friday I was showing some of the guys at the office how to write user stories with the Gherkin language to been able to use them in either Cucumber or Specflow as executable specifications.

They were receptive but they have a problem. Notepad. They wanted to use Word and have a template, and some spell checking support….

At first I got a little frustrated but I actually thought about it and try to put myself on their shoes. Here I’m, a developer, asking to the business to write specs in a very specific format. It’s not that they were negative about it, but they were expressing they concerns and they needs.

Enter Gherkin editor.

So I decided to try to create a simple editor with some of the features requested. I remembered some time ago an interview on DNR with a PM for the SharpDevelop team. He mentioned that they had the editor surface as either a service or a plug in. After searching I found it (AvalonEdit) and also a nice little sample app.

So I got the code, read the documents and after a few hours of hacking with the sample I was able to put together a super basic editor.

I hosted the code in Codeplex using Mercurial and just added the first Release 0.1 alpha, work on my machine, use at your own risk, etc, etc.

Some screenshots.

Future plans

The next step will be to add spell checker and a template to create a new document. Contextual code completion could be a nice to have. Multi language support is a must for Cucumber.

At the occasion of MIX10, which is currently taking place in Las Vegas, I'd like to announce Sesame Data Browser.
Sesame will be a suite of tools for dealing with data, and Sesame Data Browser will be the first tool from that suite.

Today, during the second MIX10 keynote, Microsoft demonstrated how they are pushing hard to get OData adopted. If you don't know about OData, you can visit the just revamped dedicated website: http://odata.org. There you'll find about the OData protocol, which allows you to publish and consume data on the web, the OData SDK (with client libraries for .NET, Java, Javascript, PHP, iPhone, and more), a list of OData producers, and a list of OData consumers.
This is where Sesame Data Browser comes into play. It's one of the tools you can use today to consume OData.

I'll let you have a look, but be aware that this is just a preview and many additional features are coming soon.
Sesame Data Browser is part of a bigger picture than just OData that will take shape over the coming months. Sesame is a project I've been working on for many months now, so what you see now is just a start :-)

I hope you'll enjoy what you see. Let me know what you think.

Sadly, I'm not at Mix this year, for the first time in a few years. It's a little harder to go if you work for Microsoft, oddly enough. And then there's this little guy next to me, who at ten days old really needs his daddy to be around! But oh, the excitement of what Microsoft has in store!

It's great to finally see all of these major releases coming together for Microsoft developer products. There is a great deal of excitement among people internally no matter where you work, because there is so much cool stuff in the pipe. In case you live under a rock...

• Visual Studio 2010 - Great to see all of the positive feedback on the Twitter and what not. I've been using it on one of my home products for awhile, and I really like it. The newer nightly builds of ReSharper also seem to be gaining speed in quality as well. I like the new debugging features, and the text readability is not imagined. Love it.
• Silverlight 4 - I've been running a couple of minor SL3 apps on my personal sites for awhile now, and I'm thrilled with the platform. With a couple of key concepts down, .NET folk like you and me can do some stellar things with this, and if you're a Mac nerd (like me), it's all kinds of awesome to be able to build stuff for it without the agony of Objective-C and X Code.
• Windows Phone 7 Series - A few weeks ago you got to see the shiny new UI that went beyond the icon grid, and now you've got the developer story as well. That I can adapt my existing Silverlight apps with minimal effort to work on the phone is pretty powerful. Millions of .NET devs just because phone developers, using the tools they already know. How great is that?
• ASP.NET MVC2 - The final bits shipped last week, and there was much rejoicing. I love this framework because of the testability and the real ability to get to the true mechanics of HTTP. The other cool thing is the speed at which the framework has evolved. v2 in less than a year is pretty "un-Microsoft" in a lot of eyes.

Mix 10 Keynote 1 on demand. (Der "echte" Anfang scheint zu fehlen, los gehts bei Minute 30...)

is live at http://msdn.microsoft.com/en-us/vstudio/dd582936.aspx for MSSDN subscribers and public tomorrow. More in an upcoming New and Notable.

One of the newest additions to the .NET 4 framework is MEF. MEF stands for the Managed Extensibility Framework and is the answer to your prayers if you are building an app that allows developers to extend its functionality by building plugins.

MEF makes the task of loading assemblies and utilizing their functionality very simple. Before we go any further there are a few basic terms that you must understand before you start using MEF:

• The Catalog is responsible for loading assemblies. There are several types of catalogs to chose from such as DirectoryCatalog and AssemblyCatalog which we will discuss in more detail later on. 
• The Container holds one or more catalogs.
• The Export attribute is used to decorate objects so they can be consumed by MEF.
• The Import attribute lets MEF know that an object is the target for one of more exported objects.
• A part is any object that is exported or imported.

So in order to start using MEF, you need to create one or more catalogs, add them to a container and then call a method named “ComposeParts” which will search the assemblies in the catalog for “parts” which are marked with export or import attributes. In order to help understand the process better, lets look at some code:

namespace WeBlog.Extensibility {
    public class WidgetManager {
        private IDataProvider _provider = Engine.GetProviderInstance();        
        private static CompositionContainer _container;
        private const string WIDGET_PATTERN = "*Widget.dll";
        private AggregateCatalog _catalog;

        [ImportMany(typeof(WidgetModel),AllowRecomposition=true)]
        public IEnumerable<WidgetModel> Widgets { get; set;}

        public WidgetManager() {            
            DiscoverWidgets();
        }        

        private DirectoryInfo WidgetDirectory {
            get {
                return new DirectoryInfo(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Widgets"));
            }
        }

        private void DiscoverWidgets() {
            //search the widget directory and also the current assembly for Widgets
            _catalog = new AggregateCatalog(
                new DirectoryCatalog(WidgetDirectory.FullName, WIDGET_PATTERN),
                new AssemblyCatalog(Assembly.GetExecutingAssembly()));
            _container = new CompositionContainer( _catalog );
            _container.ComposeParts(this);        
        }
    }
}

In the code shown above, I have a class called WidgetManager. The WidgetManager is used to manage plugins for my application. When the WidgetManager class is instantiated I call the DiscoverWidgets method.

The DiscoverWidgets method creates an aggregate catalog. An aggregate catalog is used when you need to search multiple locations for parts in MEF. In this case, we used an AssemblyCatalog and a DirectoryCatalog. In particular, this code is adding the currently executing assembly to the container in addition to all the files in the Widget directory which end in “Widget.dll”. Once the catalogs are created, we add them to the CompositionContainer. Then we call ComposeParts on the container object, which finds all the objects decorated with import or export attributes.

When this code runs, lets say that MEF finds three objects marked with the export attribute that are of the WidgetModel type. In addition, MEF also finds the WidgetManager’s Widgets property which is marked with the ImportMany attribute. The ImportMany attribute also specifies that it is looking for exports of the WidgetModel type. Therefore, MEF takes care of assigning the exported WidgetModels to the Widgets property for us automatically.  If for some reason, you do not want to automatically assign objects to a property then you can always query the container yourself. Since each composable part in the container has metadata associated with it you can use LINQ to return the objects you desire.

In case you haven’t noticed, the code in this article was taken from my WeBlog project on codeplex. WeBlog is a next generation blogging platform written in MVC 2 and .NET 4.0. I am using MEF in WeBlog to take care of loading widgets like Tag Clouds and search boxes. Here is a screenshot:

The widgets in WeBlog are displayed with the following code:

<div id="page">    
    <div id="content">        
        <div class="posts">
            <asp:ContentPlaceHolder ID="MainContent" runat="server" />
        </div>
    </div>    
    <div id="sidebar">    
        <% foreach (var widget in Engine.WidgetManager.Widgets) { %>            
            <%= Html.RenderWidget( widget ) %>        
        <% } %>        
    </div>    
</div>

Just for clarification, RenderWidget is an HTMLHelper that I wrote, which is functionally similar to the RenderPartial method. It takes a WidgetModel object as an argument and displays it on the page.

In any case, I still have quite a bit more work to do in WeBlog with regards to extensibility, so stay tuned for more MEF related posts. In the meantime, If you want to learn more about MEF then here are a few sites which you may find useful:

• Glenn Block's Blog
• The MEF site on codeplex
• MEF and ASP.NET MVC Sample – Hammett
• MEF or Managed Extensibility Framework – Creating a Zoo and Animals by Anoop Madhusudanan

Finally, if you start using MEF and you get stuck then try asking for help on Twitter. While I was putting together some code for WeBlog I posted a message about MEF on twitter using the #MEF hash tag. I was very excited when Glenn Block (@gblock) responded. Glenn is the primary developer on the MEF project. In any case, it is apparent that Glenn is very passionate about MEF and very responsive to questions. He has put together a excellent library and we should all be thankful for his hard work. Thanks Glenn!

Well here we go again another version of Visual Studios and another learning curve.  I’m starting to see the release dates being posted as of the writing of this entry however there is still no downloadable final version to be had yet.   Somehow Microsoft did not let the final release slip out to the pirates this time.

I’ve been just skimming the surface on the new functionality with a couple of video postings on learn visual studios dot net .  From what I’ve seen it appears that the new studio additions have to do with additions that where made to dot net framework 4.0 and most of this has to do with the finalized Ajax that is included in the dot net framework 4.0 release.

Additionally there is the documentation/Reporting functionality of Agile or CMMI that got it’s start with team suite 2008.

I’ll be looking for a good Ajax project to do a screen cast of here in the near future.  The post have been a little far an few between here. I’ve been a little busy with life and little less with dinking around programming.

I blogged about sample data in Microsoft Blend/SketchFlow previously. SketchFlow is a great tool for rapidly building interactive screen prototypes. Sample data feature helps you to create plausible screen mocks quickly. I want to emphasize words interactive prototypes. Yes, user can click here and there and sees the entire “application flow”. Previously we mocked screens in HTML, had them rendered and sent this to our customers as a package full of JPEGs. Almost as a rule we had small disputes with customers who were arguing that they just cannot “grasp the application” from JPEGs. Now we can just publish a Silverlight prototype to our server and customers browse it throughout.

Hopefully I don’t need to note that logically connected screens should play together. Having double clicked a record in a datagrid on one screen and being redirected to another screen showing detailed information on this only record, data in fields should be the same (or related) to the record I clicked on the first screen. If you use sample data, it means that you should bind the first and second screen against the very same data source.

One problem I encountered is managing data derived from other fields in sample collection. Let’s say I have a customers collection with usual data like first name, last name and birth date. The first screen shows this list but I want to have only one column for customer name showing first and last name concatenated. I need them separated in my collection because the second “customer detail” screen would show them in separate text boxes. I could create a new string field and manually type in the full name but I am lazy to do such work and frankly have personal objections to do so. I prefer the way the full name field just computes itself. That way I can modify either name and full name updates automatically.

Double clicking on the Natasha row would bring me to the second screen with separate fields:

Fortunately, this task is not difficult. Your sample data collections are stored as XML files inside the SampleData folder in the XXXScreens project. For each such XML file, Blend generates a corresponding C# file with two ordinary class, one representing the collection and one the collection item (named Item):

public class Employees : System.ComponentModel.INotifyPropertyChanged
{
    public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged(string propertyName)
    {
        if (this.PropertyChanged != null)
        {
            this.PropertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs(propertyName));
        }
    }

    public Employees()
    {
        try
        {
            System.Uri resourceUri = new System.Uri("/SilverlightPrototype_Derived.Screens;component/SampleData/Employees/Employees.xaml", System.UriKind.Relative);
            if (System.Windows.Application.GetResourceStream(resourceUri) != null)
            {
                System.Windows.Application.LoadComponent(this, resourceUri);
            }
        }
        catch (System.Exception)
        {
        }
    }

    private ItemCollection _Collection = new ItemCollection();

    public ItemCollection Collection
    {
        get
        {
            return this._Collection;
        }
    }
}

public class Item : System.ComponentModel.INotifyPropertyChanged
{
    public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged(string propertyName)
    {
        if (this.PropertyChanged != null)
        {
            this.PropertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs(propertyName));
        }
    }

    private string _LastName = string.Empty;

    public string LastName
    {
        get
        {
            return this._LastName;
        }

        set
        {
            if (this._LastName != value)
            {
                this._LastName = value;
                this.OnPropertyChanged("LastName");
            }
        }
    }

    private string _FirstName = string.Empty;

    public string FirstName
    {
        get
        {
            return this._FirstName;
        }

        set
        {
            if (this._FirstName != value)
            {
                this._FirstName = value;
                this.OnPropertyChanged("FirstName");
            }
        }
    }
}

Pretty boring code. If only the Item class would be generated with the partial directive, we could add our own class with the FullName computed property.

Let’s start some hacking then. Close Blend, start your favorite text editor and open the file C:\Program Files\Microsoft Expression\Blend 3\Templates\en\SampleDataCode.cs. This is the template Blend uses for generating C# code from the sample data XML source file.

Change line 43 from:

public class COMPOSITE_TYPE : System.ComponentModel.INotifyPropertyChanged //CompositeTypeHeader - BEGIN

to:

public partial class COMPOSITE_TYPE : System.ComponentModel.INotifyPropertyChanged //CompositeTypeHeader - BEGIN

Now start Blend again, open your project, force Blend to regenerate the code file (by adding a new property and removing it immediately). If you open the sample data code file, you can notice that the Item class now has the partial keyword!

Add a new class, change the namespace to exactly math the one in the original code file and write your own partial class, like mine:

namespace Expression.Blend.SampleData.Employees
{
    public partial class Item
    {
        public string FullName
        {
            get
            {
                return string.Format("{0} {1}", FirstName, LastName);
            }
        }
    }
}

Job done! I may create a new bound column to my datagrid:

<data:DataGridTextColumn Header="Full Name" Binding="{Binding FullName}"/>

Note: Blend may not recognize your new properties, so you may need to write your bound fields in XAML yourself, not in the Blend UI.

One of the things I’ve noticed is that two industry trends are not playing nice together, those trends being multi-core CPUs and massive hard drives.  It’s not a problem if you keep your cores busy with compute intensive work, but for software developers the beauty of multi-core CPUs (along with gobs of RAM and a 64 bit OS) is virtualization.  But when you have only one hard drive (who needs another when it holds 2 TB of data?) you wind up with a serious hard drive bottleneck.  A solid state drive would definitely help, and might even be a complete solution, but the cost is ridiculous.  Two TB of solid state storage will set you back around $7,000!  A spinning 2 TB drive is only $150.

I see a couple of solutions for this.  One is the mainframe concept of near and far storage: put the stuff that will be heavily access on a solid state drive and the rest on a spinning drive.  Another solution is multiple spinning drives.  Instead of a single 2 TB drive, get four 500 GB drives.  In total, the four 500 GB drives will cost about $100 more than the single 2 TB drive.  You’ll need to be smart about what drive you place things on so that the load is spread evenly.  Another option, for better performance, would be four 10,000 RPM 300 GB drives, but that would cost about $800 more than the singe 2 TB drive and would deliver only 1.2 TB of space.

All pricing based on Microcenter as of March 14, 2010.

The Code Generation conference is Europe's leading event on Code Generation and Model-Driven Software Development.

The conference program is now available and booking is now open. 

Artech presented a purposal and it was accepted. So I'll be there talking about Model Driven Database Schema Evolution.

The samples will be Deklarit and Genexus

To avoid over tweeting/blogging I have decided to try to maintain a list of DNN related links for weekly publication.

Here is this week…

Looking for free dotnetnuke skins for your dnn website?

Lehigh County, Pennsylvania – New DotNetNuke Case Study

DotNetNuke raises $8 Million in Series B funding

Features of DotNetNuke Development

DotNetNuke Makes It Easier For You To Build Feature-Rich, Interactive Web Sites And Applications

Creating Testable Modules – Redux – Now Baked into the Core (DotNetNuke Corp Adopts MVP Pattern)

DotNetNuke Connections Call for Speakers

DotNetNuke 5.3.0 Alpha Release

DotNetNuke Lightbox Gallery Module Version 01.02.00 Released (Free)

DotNetNuke® Essentials: Simple Solutions for Building Your Website (Webinar)

DNN Corp hosts first San Francisco DNN User Group Meeting

Tons this week.  Vladimir Matveev’s is my favorite new F# blogger with very well written data structure posts, Ashley Feniello continues his fantastic FScheme series, and Jomo Fisher posts some great Freebase and DGML examples.  That’s just the tip of the F# iceberg, do come inside.

Ashley Feniello’s FScheme Parts Twelve, Thirteen and Fourteen

The basic idea is to run a simulation by iterating a pure function from world state to world state. We’ll add a new ‘run’ primitive which will expect several user-defined functions to have been set up. The world state is initially produced by an ‘init’ function. Then every 30th of a second a ‘tick’ function is called to produce a new world state from the current state. Finally a ‘draw’ function will be called to render the world.

Luca Bolognese’s Updated Stock Prices, Divs and Splits Example

I’m working on a program to keep track of paired trades with trailing stops. I need to download stock prices, so I thought I might reuse some old code of mine. Here is the updated framework.

David Carlisle’s NAG F# Examples

NAG (Numerical Algorithms Group) is currently running a beta test of a NAG Library for .NET. One noticeable feature of the comments received so far is the relatively large number of users interfacing to the library from F# rather than C# or VB.NET.

Phillip Trelford’s The Associative Model of Data

But what if you wanted to extend the web store to have features like the online retailer Amazon, e.g. multiple sellers, recommendations, etc.? Answer: serious table and relationship proliferation. Enter an alternative model: the Associative model of data, a dynamic model where data is defined simply as items and links.

Jon Harrop’s F# vs Unmanaged C++ for Parallel Numerics

We obtained a surprising performance result when comparing optimized parallel ray tracers written in F# and C++ recently. The following two programs render the same highly complex scenes containing over a million objects. Surprisingly, the 136-line managed F# program runs slightly faster at 17s than the 168-line unmanaged C++ which takes 18s.

Vladimir Matveev’s F# and Iron Pyton

Today’s post will be devoted to various ways of integration between Iron Python and F#. I’ll try to skip the details of DLR configuration, because this is vast topic that worth separate post (maybe even a few posts). Instead I’ll focus on questions of integration.

Vladimir Matveev’s Data Structures: Finger Tree (Part 1)

What we’ll try to do in this post is to create the structure (based on 2-3 trees) with following characteristics.  Immutable (modification returns new instance of structure with changes applied),  Enqueue/Dequeue both in start and end in amortized constant time, and Concatenation support.

Vladimir Matveev’s Data Structures: 2-3 Tree

There are many special types of trees that perform insert/remove operation in intelligent way ensuring that result tree is small but branchy :). This trees are called self-balanced, most well-known of them are AVL trees, Red-black trees, 2-3 trees. This post is dedicated to the latter ones.

Vladimir Matveev’s Overview of F# Async Module and Event-based Async Pattern in F#.

This post I’d like to dedicate to reviewing functionality of Async module – creating and manipulating async computations.

Luis Diego Fallas’s Basic Image Processing Operations with F#

The previous post presented a way to access the image data from the Webcam using DirectShow.Net and F#. We can manipulate this data to do some basic image processing operations with it.

Jomo Fisher’s Extend your F# program with MEF and MEF in F# Scripts

The Managed Extensibility Framework is an interesting new technology in .NET 4.0.  This is a simple example in F#. This code sets up MEF hosting and asks for all extensions in the c:\extensions folder.

Jomo Fisher’s Neat Samples: F#, Freebase, DGML

I recently posted about the freebase web service here. This sample reads biological classifications and renders them in DGML. The result is a huge graph, here’s a little piece of it…

Jomo Fisher’s Neat Samples: F# and Bing API

Here’s another F# web service sample. This one uses the Bing Phone API to do a query. This time the code uses Xml instead of JSON and XmlDocument instead of a DataContract deserializer. This is pretty much a straight transliteration of one of the Bing SDK samples.

Jomo Fisher’s F# and Freebase

The web service at Freebase.com lets you access all sorts of structured data from a web service. Here’s a sample that shows you how to access this data from F#. It uses DataContract and the JSON serializer. The code below reads and prints the elements of the periodic table.

Julien Ortin’s BitTorrent in F# series: I/O Operations and Bitfield

One important thing is that a BitTorrent transfer is considered as a stream of pieces. So, if you have a 100-byte file, and a 400-byte one, and if the piece size is 200-byte long, the data from the piece need to be appropriately split (both when reading and when writing).  In this library, we use a reference to the AsyncWorker described on Don Syme’s blog.

Matt Moloney’s Drag and Drop using Rx and WPF in F#

I have recently been experimenting with combining Reactive X, WPF, and F# and have found the combination to be very palatable. I chose drag and drop as the test case because it is both non trivial and generally deeply stateful. The resulting Rx turns out to be one fifth the code of my original C#, much easier to read and has fewer errors.

Kean Walmsley’s Using jig from F# to create Spirograph patterns in AutoCAD

After my initial fooling around with turning AutoCAD into a Spirograph using F#, I decided to come back to this and bolt a jig on the front to make the act of making these objects more visual and discoverable.

Joh’s Thoughts about F# and Xbox games

I have been working for quite some time now on Asteroid Hunter. This has not left me much time for exploration with F#, but there is quite a bit a learned during the process anyway.

Richard Minerich’s Abstract Thoughts about F# Abstractions

My recent work on Professional F# 2.0 has left me thinking a lot about the nature of abstractions.

Oliver Strum’s Creating a Lazy Sequence of Directory Descendants

I thought these code examples all look rather verbose – in the case of Clojure because in that way rather typical for Java, the APIs are pretty verbose to use, and in the case of C# because of all the syntactic, well, ahem, necessities, as well as the fact that there’s no language feature for integrating nested sequences seamlessly. Keeping it nice and simple, in F# that example can look like this…

Tormod Fjeldskar’s Tail Recursion in C# and F#

Tail recursion is essential in functional languages like F#, where iterative solutions are often implemented using recursion.

I just twittered a few minutes ago, saying “Seems like VS 2010 can still not show the same file twice in panels next to one another. Am I missing something?". I’m still interested in the answer, if there is one, but meanwhile I thought I’d blog about something I’ve found interesting for a long time: the way our heads seem to work differently when it comes to applications of the words “horizontally” and “vertically".

You see, in Visual Studio (and that has been the same thing with MDI windows before that), they have a thing called a “Tab Group", which comes in horizontal and vertical varieties. These days the difference is illustrated in little icons at least, defining it like this:

Horizontal group (exhibit A):

+--------------------+
|                    |
+--------------------+
|                    |
+--------------------+

Vertical group (exhibit B ):

+-------+-------+
|       |       |
|       |       |
|       |       |
|       |       |
|       |       |
|       |       |
+-------+-------+

Now here’s my gripe with that: it’s the wrong way round!

In my eyes, exhibit A might be described as “a tab group with a horizontal splitter", but it is not a horizontal tab group. These things are not the same. A horizontal tab group is one where the tabs, the defining feature of a tab group, surely, are shown “horizontally", i.e. next to each other in horizontal direction. Just like exhibit B, in fact. And vice versa, of course.

I don’t know what somebody was thinking when they came up with those names, or maybe it’s just my head that works differently. It doesn’t make sense to me, in any case. And that’s the important point of this post: if you never realized that these terms might be confusing to somebody, here you are now!

One important factor in successful communication is about understanding misunderstanding – which is why, in my tweet, I was avoiding the terms “horizontal” and “vertical” as being confusing in the context. Of course the first and so far only reply I got to my tweet (and I’m not naming any names here <g> ) went “hey, do you mean vertically?” Hmpf.

Oh, and yes, according to the MS definition I mean vertically, yes. A tab group with a vertical splitter, that has been split in vertical direction, or whatever. A tab group with the tabs showing horizontally next to one another. And the same file on both sides of the splitter. Not possible, is it?

Eine weitere Ankündigung im Vorfeld der MIX-Konferenz: Microsoft Silverlight Analytics Framework wird als Open Source Framework nächste Woche auf Codeplex veröffentlicht. Folgende Anwendungsszenarien und Themen werden mit dem Framework addressiert:

• Out-Of-Browser Szenarien
• Offline Szenarien
• Mehrfache Analytics Services gleichzeitig ohne Performanz-Einbüßen
• Designer-Unterstützung für Microsoft Expression Blend 
• A/B Testing
• SketchFlow Prototyping
• Logging und Video Experience mit Microsoft Silverlight Media Framework [2]

In der Session [1] erläutern Michael Scherotter und Alfonso Corretti die Details des neuen Frameworks zur Integration von Web Analytics Lösungen in die Silverlight-Applikationen. Eine weitere Session auf meiner Agenda.

[1] http://live.visitmix.com/MIX10/Sessions/CL24
[2] http://smf.codeplex.com/

Ok, ricapitoliamo:

• Domani saremo a Roma in occasione del DotNetCampus: l’agenda è molto varia e tocca un “sacchissimo” (unità di misura da poco entrata nel S.I. <g>) di argomenti interessanti. ‘nzomma, se fa ancora troppo freddo per andare in giro a caXXeggiare, potreste pensare di venirci a trovare :-)
• Il prossimo mese torneremo a Roma grazie alla ospitalità di BASTA! Italia, che anche quest’anno ci permette di organizzare un “Community After Hour” gratuito in combutta con i ragazzi di ASPItalia. 3 sessioni, 2 delle quali già in agenda e potenzialmente “rissose” giacché dedicate a temi in merito ai quali crediamo che il formato “open” possa portare grande valore aggiunto. E ricordatevi che i soci UGIdotNET hanno uno sconto sulla iscrizione all’evento diurno

The dates are as follows:

March 29th - Early Adopter Program

The early adopter release will be available to a limited set of EntitySpaces customers who have a real need for some of the new or enhanced EntitySpaces 2010 features (such as Silverlight, WCF, Smart Proxies, SQLite, JSON serialization). We are looking for customers who desire to upgrade to ES2010 now and continue developing through to release. Prime candidates are new customers working on projects that haven’t shipped yet who can easily upgrade and begin working with ES2010. If you are interested in participating in our Early Adopter Program please send an email to earlyadopter@entityspaces.net with your EntitySpaces user id and how you plan to use EntitySpaces 2010. Not everyone who sends an email will be chosen to participate. Again, we are looking for users who are really going to use this version for development. We are seeking about 20 users to participate and they will be hand picked based on the email we receive explaining how ES2010 will be used. For example, we are interested in Windows Forms, ASP.NET, Silverlight, and so on, in other words, a good cross section of development. Current forum participation will also help in being chosen (active users).

Keep in mind that EntitySpaces 2010 will not support .NET 2.0, it’s .NET 3.5 and forward. We are unsure at this point if .NET 4.0 assemblies will be included in the Early Adopter Program.

April 19th  – Public Beta (customers only)

We are planning on only one beta. This beta will be available to all customers. We realize that the beta window looks short here but this release will have passed all of our unit tests and will have been pretty heavily used by those participating in the Early Adopter Program.

April 29th – Official Release

This is our official release. The EntitySpaces 2010 Trial version will also be available as well for the general public.

From Mobile Devices to large scale enterprise solutions in need of serious transaction support, EntitySpaces can meet your needs. Whether you’re writing an ASP.NET application with Medium Trust requirements, a Silverlight/WCF application, a Mono application, or a Windows.Forms application, the EntitySpaces architecture is there for you. EntitySpaces is provider independent, which means that you can run the same binary code against any of the supported databases. EntitySpaces is available in both C# and VB.NET. EntitySpaces uses no reflection, no XML files, and sports a tiny foot print of less than 200k. Pound for pound, EntitySpaces is one tough, dependable .NET architecture.

EntitySpaces LLC
Persistence Layer and Business Objects for Microsoft .NET
http://www.entityspaces.net