Silverlight Hack

Silverlight & related .NET technologies

About Me

Welcome to  This is a site where you can find many articles on Silverlight, Windows Phone 7 and .NET related technologies.  

My name is Bart Czernicki.  I have been working with computers since 1988 and have over 12 professional years in the IT field focusing on architecture, technology strategy and product management.  I currently work as a Sr. Software Architect at a large software development company.

Below is the cover of my new book that shows how Silverlight's unique RIA features can be applied to create next-generation business intelligence (BI 2.0) applications.

Silverlight 4 Business Intelligence Soft 


View Bart Czernickis profile on LinkedIn

NONE of the comments or opinions expressed here should be considered ofmy past or current employer(s).  The code provided is as-is without anyguarantees or warranties.

Are you ready to learn F#? Concepts to be familiar with before learning the F# language

I have been learning, absorbing and playing with F# for several months now.  I worked primarily with C# since 2002.  I figured I would write some .NET and developer concepts that one should be familiar with before trying to learn F#.  Hopefully, the list compiled below will help you determine if you are ready to learn F#.  If you are not familiar with most or any of these items below, it doesn't mean you can't learn (or shouldn't learn) F#.  However, in my opinion, the more you know from the items listed below, the easier it will be to learn the language.

Background Information

F# is a new functional programming language (from Microsoft) that is being released with .NET 4.0 and Visual Studio 2010 in March 2010.  The language is a "first-class" language and is completely integrated with the entire .NET ecosystem (debugger, tools, framework, support) like C#, C++.NET and VB.NET.  Therefore, F# is not like Delphi.NET, COBOL.NET or other third-rate .NET languages.  Functional languages are based on mathematics and this makes them ideal for statistical, financial operations on large data sets.  F# is a unique .NET language that will have many uses in the near future.

Programming Concepts

This is a list of programming concepts you should be familiar with before learning F# (Note: I ommited a lot of beginner programming concepts). You will see a lot of these concepts/patterns used in F# programs and examples.

  1. Data Structures - You should have a good understanding of the differences between a linked list, array, hash set, etc.  F# natively uses certain data structures (in underlying types) and knowing the differences between them will aid you when writing programs.  If you need a refresher, check out this FREE PDF book Data Structures and Algorithms Book.
  2. Big Oh Notation - You have to be able to understand the performance implications of your algorithms.  This is especially true for functional programming languages like F#.  If you do not know the difference between O(1) or O(n), you need to refresh your memory.  This is important when writing functional (non-imperative) style programs when doing many operations on a sequence or list of types.
  3. Type Inference - By default,  the F# compiler uses type inference to determine what types a function uses.  C# has partial type inference using the var keyword.  However, in C#, you still need to pass in the type explicitly for method signatures.  Being used to not seeing these "type aids" will help you understand F# syntax faster.
  4. Immutability -  In object-based languages such as C#, C++ or VB.NET the created objects are mutable.  This means that their state can be changed.  Functional programming languages are by default immutable and do not allow the state of the value/variable to change after it has been assigned a value.  For more information on immutability go here.
  5. Recursion - Recursion is the ability of a piece of code to call itself over and over until the desired result has been completed.  In C#, methods can be recursive.  In SQL (SQL 2005), a developer can use CTEs (common table expressions) to recursively iterate through the same algorithms.  This pattern is very popular in functional programming and whatever F# book you pick up, this will be one of the first chapters you read.  If you are familiar with the more advanced topic of recursion like "tail recursion," that will be really beneficial as well.  For more information on recursion, click here.
  6. Closures - Closures are a more advanced topic that most developers use every day without even knowing it.  Closures allow you to use constructs that are declared outside of the scope of the function as if they were part of the local scope.  I recommend Jon Skeet's book to fully understand them.  A link to an article on his website can be found here.
  7. Currying -Function/method currying is the process of creating new functions/methods from existing functions/methods and their parameters.  You will see function currying in a lot of F# examples as it makes code simpler and easier to read.  For more information on currying, click here.
  8. Iterator pattern - I think this is one of the more important design patterns.  For example, as a .NET developer, you should know the difference between a List type and an IEnumerable and how to use the yield keyword to implement the iterator pattern in C# (In F#, an iterator is implemented in a sequence).  As mentioned above, functional programming languages are designed to work with lots of data.  Therefore, optimizing data structure access is essential to create performant F# modules.  For a great article on the iterator pattern, please look at Juwal Lowy's MSDN article.
  9. Asynchronous Programming - Since F# is by default immutable and tries to get the developer to program without side effects, this makes it great for asynchronous programming.  The reason is that by definition, all constructs should be thread-safe since their state cannot change.  Knowing about async programming helps, but it does not mean you can't do synchronous F# programs.
  10. Writing Clean Code - In my opinion, this is probably the most important one of all.  When writing C# code, you have curly brackets and semicolons to aid you in laying out your code and determining scope.  However, in F#, the way you lay out code matters!  This means whitespace and bad code formatting could create unwanted bugs.  The reason I mention this as important is that this could be a hard habit to break.  For example, learning about closures could take a very small amount of time compared to breaking a bad habit in formatting your code.
  11. Other functional languages - This is an obvious one. If you have experience with other functional languages such as Haskell or OCaml, you will obviously feel right at home with F#.

.NET/C# Concepts that Translate to F#

This is a list of .NET/C# concepts that translate well into F# and will help you understand functional programming more easily.

  1. LINQ/SQL - If you have used LINQ or SQL, this will dramatically help you understand how to write functional algorithms.  LINQ/SQL favor declerative (opposed to imperative) syntax like F#.
  2. Lambda Syntax - If you are familiar with lambda syntax in C#, you will see a very similar lambda syntax in F#.
  3. Extension Methods - This could be associated with knowing LINQ but it is worth mentioning here as extension methods are essential in "fluent" code.
  4. Generics - Generics were introduced to the .NET framework to aid in code reuse.  In the same manner that you can write a generic method in C#, you can write a generic function in F#.
  5. Delegates and Simplified Delegate Syntax - If you have used delegates as parameters or to pass pieces of code around, then the functional composition concept will be familiar to you in F#.  You can read my Evoloution of C# Delegate Syntax article to understand how delegates allow you to write code in a more functional paradigm using C#.
  6. Parallel Task Library/PLINQ - Writing algorithms that can take advantage of many cores should not be hard.  This is exactly what the Parallel Task Library/PLINQ allows you to do in .NET 4.0 in a simpler, functional way.  These concepts are closely aligned to F# asynchronous workflows which allow concurrency (even in Silverlight!!)
  7. var Keyword (type inference) - Being familiar with the var keyword in C# will get you familiar with type inference in F# faster.  Most F# examples make use of this feature and declare types explicitly only when needed.


If you read reviews of available F# books, some are negative - in my opinion, unfairly - because the developers expect to be taught everything.  There are a lot of core concepts listed above that a single F# resource simply cannot cover.   Understand when purchasing F# resources, you are expected to know a decent amount of these developer topics.  I hope this list aids you in the way you approach learning F# either by jumping into F# directly or by brushing up on some intermediate/advanced programming concepts.

Getting started with F#

Information on F# has been around for several years.  There are many articles, white papers and books on F#.  However, you do have to be careful and get content that is recent and relative to the current F# release.  The F# specification has changed dramatically over the last several months as the language was being "productized" and many methods/functions simply don't exist in F# anymore.   Below are some links I put together where to get started.


  • Getting Started with F# - This video (from the 2008 PDC) is the place to start if you have zero F# experience and/or if you want a really good introduction into functional programming and some F# examples.

Books (I have read four different F# books and the two below are by far the best ones and most current.  Don Syme's F# book is good but a little outdated.)


  • This the main Microsoft F# page.  Includes numerous links, downloads for Visual Studio, F# extensions, etc.
  • Don Syme's blog - Don Syme is one of the main "creators" of F#.  His blog is a must read to get insight into advanced topics and upcoming F# news.


kick it on
Posted: Dec 06 2009, 12:29 by Bart Czernicki | Comments (3) RSS comment feed |
  • Currently 5/5 Stars.
  • 1
  • 2
  • 3
  • 4
  • 5
Filed under: .net | F#
Social Bookmarks: E-mail | Kick it! | DZone it! |

Solution Composition in Windows Azure Cloud Service Project Template

Goal: This blog post aims to show you the new solution composition feature in the "Windows Azure Cloud Service" project type.  In addition, I posted some additional thoughts on how this could be expanded as a very useful starting point for all projects.

The new "Cloud Service" project template includes a new feature (This is my name until Microsoft officially names it) "solution composition".  In Visual Studio 2010 Beta 2 (if you install the Windows Azure SDK), you will see a new Cloud Service template.  Through the screen shots below, I am going to highlight some of the key features of "solution composition". 

Cloud Service (Azure) Project Type

Selecting the Cloud Service template brings up an additional dialog box that allows you to add a number of additional project types.  Currently VB.NET, C# and F# web role and worker role projects are supported.  Selecting the project and selecting the arrow button adds this project to the Cloud Service solution.

If you need several projects of the same type, you can add multiples of the same type.  Notice the screen shot below illustrates a solution with three seperate C# worker role projects (assemblies).

Once added, project names can be renamed or removed.  Red arrows below highlight the controls that allow editing of a project.

After clicking the OK button, a complete Cloud Service solution is created with all the projects properly added to the roles folder.

Why Does This Matter?

If you have architected large-scale n-layer prototypes or projects, you can clearly see the benefit of "solution composition".  This allows you to select the projects you want ahead of time and "compose" a single solution.  For example, imagine you want to create a Silverlight application with a WCF service.  You might start with a Silverlight ASP.NET project type.  However, then you need to manually add all the projects yourself and properly add the references between them in Visual Studio (i.e., WCF service project, BLL assembly, DAL assembly, LINQ to SQL dbml, Silverlight BLL, etc.).  It would be much better to simply select the projects that will compose your solution and have Visual Studio generate the whole solution. 


Solution Composition Features I Would Like to See

The Cloud Service template in Visual Studio 2010 Beta 2 is a step in the right direction; however, it can be greatly improved.  These are some of the items I would like to see:

  • Make "solution composition" available for all Visual Studio 2010 templates.
  • Allow the architect/developer to build a dependency/reference tree between projects.
  • Integrate the solution folders feature (Allows you to logically organize the solution).
  • Allow the architect/developer to add specific functionality to a project.
    •  For example, if I want to have a DAL that uses LINQ to SQL, the ability to "checkbox off" and add a LINQ to SQL class
  • Allow the architect/developer to specify the assembly references for each project (.NET, custom toolkit, etc.).
  • Include a "smart namespace naming" feature.  Assemblies are named namespace+project name.
  • Ability to save the entire "solution composition" as a template itself for future use
    • Integrate with TFS and replicate to all developers (?)
    • Add diagraming feature

How Useful is This?

After reading this, you might be thinking that this is overkill and how often are you creating "large solutions".  If you have prototyped a lot of solutions, this will be a Godsend.  Furthermore, a lot of consulting shops that have to quickly generate client-specific prototypes would greatly benefit from this feature  In my opinion, the more tedious (plumbing) tasks that are automated, the more I can focus on architecture or design of software solutions.

kick it on
Posted: Nov 15 2009, 16:27 by Bart Czernicki | Comments (0) RSS comment feed |
  • Currently 0/5 Stars.
  • 1
  • 2
  • 3
  • 4
  • 5
Filed under: Azure | Visual Studio 2010
Social Bookmarks: E-mail | Kick it! | DZone it! |

Connecting to SQL Azure with SQL Server Management Studio 2008 R2

Goal: Show a user how to connect to a SQL Azure Server from SQL Server Management Studio 2008 R2.  If you don't have a SQL Azure account you can treat this post as information to further your knowledge about Microsoft cloud storage

As of 11/10/2009, SQL Server 2008 R2 is feature-complete as well as SQL Azure.  The new version (PDC 2009) of SQL Azure has been provisioned on all of the production servers.  The current version of SQL Server 2008 R2 available is CTP which is a publicly available beta of the Enterprise Edition (Note: Enterprise Edition is not the highest edition anymore.  Since SQL 2008 R2, Microsoft has added Premium Editions that allow for massively-scalable database servers).

What you need to follow along:

- SQL Azure Account (active)

- SQL Server 2008 R2 Management Studio Installed (Download just the Management Studio tools here)

For the initial release being shown at the PDC 2009, SQL Azure includes some new configuration features that need to be enabled in order to connect:

  1. Log in to with your account information

  2. Go to the SQL Azure tab to access your projects (If one doesn't exist, create one.)

  3. Click on the project row to access the SQL Azure Server Administration screen.

  4. If you do not have a server SQL Azure server provisioned, you will be asked to create one.

  5. In the SQL Azure Administration Screen you can
    1. Drop/Re-create a server
    2. Reset the admin password
    3. Get a connection string to the database server
    4. Test the server connection (send a connection ping)
    5. Manage your databases
    6. Change the Firewall Settings

  6. Create a sample database and click the "Test Connectivity" button to ensure you can connect via the network/firewall to the remote Azure server.  This step should be done to make sure that you do not have any network or firewall issues.  Furthermore, this ensures that the server and database were properly provisioned in the Azure Cloud and are fully functional.

  7. Open SQL Server 2008 R2 Management Studio and in the Server Name text box, enter the name of the SQL Azure Server from the Server Administration screen (Shown in Step 5).  Make sure you copy the fully qualified DNS name (as shown in the screen below).  Ensure that the Server Type is set to Database Engine and the Authentication is set to SQL Server Authentication.

  8. Try connecting by hitting the Connect button. If you get an error similar to the one shown below that states your IP does not have access, you need to configure your SQL Azure Firewall settings.
    1. SQL Azure (as of the October 2009 version) includes Firewall Settings manager that allows you to explicitly control which IP addresses are allowed to connect to your Azure database server.  This was done to alieviate customer concerns regarding placing sensitive data on Microsoft's server.  If you specify that only your network can access the database server, this gives you more piece of mind that a hacker hasn't hijacked the user/password and can connect.  Furthermore, it is more secure and a best practice to do this.

  9. In order to fix this, we simply need to allow the IP address you are connecting from in the Firewall Settings manager.
    1. One question you may be asking is, what do I do if I have a dynamic IP"?  For example, if you have a broadband connection such as DSL or FIOS, your IP address can change over time.  This would be really annoying if you had to add a firewall exception every other day!  One way to get around that is to find your ISP's IP range and enter that in the exception.  It is not as secure as providing a single static IP address however.  It is much more secure than opening up SQL Azure to the entire Internet (full range of IPs). Most ISPs will provide the range for your area if you call them.  Some even publish this information on their knowledgebase/support.

  10. Go back to the SQL Azure Server Administration screen and click the Firewall tab.  Clicking the Add Rule button will bring up a model popup where you can enter the name of the Firewall rule and enter either a range of IPs or a single IP:
    1. The popup lets you know what your current IP address is.  You can simply copy and paste it into both locations.  You can enter as many locations as you need.  For example, you may have a home network, wireless card with an IP range, work network, etc.
    2. If you have an ISP that has a dynamic list of IPs, enter the IP range that was provided to you.
    3. This is NOT recommended, but you could add a rule that opens up the entire IP stack of the Internet by entering ->
    4. If you are not comfortable with an IP range, another solution is to use a "proxy service" and this will masquerade your IP to something else.  Static IP addresses cost money; however, they can be useful in these situations.
    5. The dialog mentions that it could take up to five minutes to connect. I tried this several times and after one minute, you should be able to connect.

  11. You should be able to open up SQL Server 2008 R2 Management Studio and connect to your SQL Azure database. If you are successful, you will see your database in the Object Explorer (shown below)




You should now be able to configure an SQL Azure database and connect to it via SQL Server Management Studio.  Managing a SQL Azure is a little different and in my next post I will show some of the features of managing SQL Azure with SQL Server 2008 Management Studio.

kick it on
Posted: Nov 11 2009, 16:08 by Bart Czernicki | Comments (1) RSS comment feed |
  • Currently 0/5 Stars.
  • 1
  • 2
  • 3
  • 4
  • 5
Social Bookmarks: E-mail | Kick it! | DZone it! |

Silverlight 3 and F# Support in Visual Studio 2010

The goal of this blog post is to make you aware of F# support in Silverlight in Visual Studio 2010.  In addition, this blog post shows an example why F# is going to be very important for Silverlight architects and developers.  Note:  This is NOT an intro to F#.

Demo and Visual Studio 2010 source code are provided with this article.

In Visual Studio 2010, F# is a first-class language.  Over the last several months, the language has been "productized."  It is officially part of the Visual Studio 2010 ecosystem (tools and .NET 4.0 framework).  However, F# is not limited to the full .NET framework; it is also available in the Silverlight runtime.  This is really exciting as this allows you to take advantage of functional programming features in Silverlight.


In Visual Studio 2010, the "F# Silverlight Library" project is natively supported.


Silverlight 3 application that includes an F# assembly.


Why should I care about F# in Silverlight?

Most C# developers/architects who do not have experience with functional programming language features could assume that F# is another language like Visual Basic, J# or C++.  It would be wrong to compare F# to any of these languages (including C#).  As a functional language, F# allows developers to design software using the functional paradigm.  What does that mean?  This means functional patterns such as interactive programming, pattern matching, immutable data types, type inference, lambda expressions, workflows, higher-order functions, discriminated unions, etc., are all included in F#.  While taking advantage of these features, a developer using F# can use the type system, implement object-oriented design and make use of the .NET classes.  This makes F# a very unique language that combines all the features of a first-class .NET language (i.e., C#) and a professional functional language.

Note: F# compiles to IL just like any other .NET language.  However, F# has been designed from the ground up over the last couple of years.  Therefore, the IL it generates has been optimized and many new language optimization features have been implemented.  For example, you may have seen blog posts that compare C# and F# syntax that shows F# compiling into cleaner IL and faster code.  Conversely, C#'s core functionality has not been redesigned in about a decade (C#/.NET has been extended with functional features such as type inference, extension methods, lambdas, AST, LINQ, etc.)


Show me some code that proves how F# can add value to Silverlight

This short blog post is not meant to be an F# introduction (Please see links below for intro material).  However, I did want to pick at least one compelling feature that really shows off the power and functional brevity of F# married with Silverlight functionality.  The feature that I decided to show off in a Silverlight F# module is a concurrent programming pattern.

If you do not already know, Silverlight supports distributing logic up to eight processor cores (This frustrates me that Microsoft doesn't adverstise this enough). In my opinion, concurrent programming is THE biggest feature of Silverlight over other RIA technologies (i.e., Flash, JavaFX).  However, implementing asynchronous patterns in Silverlight is not trivial.  The callback pattern is messy and leads to a lot of code.  Silverlight runs in an STA mode and requires UI elements to only be modified by the main thread (dispatching or synchronization).  Even asynchronous constructs like the BackgroundWorker that are supposed to make concurrent programming simple lead to many messy lines of code with events.  Wouldn't it be great to get the benefit of asynchronous programming without having to write many lines of additional code?

One of the fantastic features of F# is that the default type immutability and functional design allows the language to express the desired result declaratively.  This means you write F# syntax by telling the program what you want it to do rather than how to do it.  For example, if you are using constructs that use secondary threads and allocate code to these threads, then you are writing imperative code.  A lot of lines of code are wasted telling the code how we want it to behave.  Wouldn't it be better to define pieces of logic and simply say that we want them to execute in parallel?  Functional declarative code in F# can do exactly that.  F# includes a feature called asynchronous workflows that allow you to write logic by composition with the aim to be executed in parallel.

Initial Steps

  • I created a simple Silverlight application.
  • I added an "F# Silverlight Library" project
  • In the F# assembly, I added an F# code file called ConcurrencyTest.fs.
  • I created an F# function called addNumbers that takes two parameter:
    • The first parameter is an accumulator that is the existing sum in the running sequence (This will be passed by the reduce sequence function).
    • The second parameter is the number in the sequence we want to add.
  • I created an F# function called squareNumber that takes two parameters:
    • The first parameter is an accumulator that is the existing square sum in the running sequence (This will be passed by the reduce sequence function).
    • The second parameter is the number in the sequence we want to square.
  • I created an F# function (equivelant to a C# method) that takes no input parameters named PerformTwoLongRunningTasks:
    • Inside that function, I defined two tasks that use the addNumbers and squareNumber functions to add the numbers across a sequence of numbers from 0 to 10,000,000
    • The PerformTwoLongRunningTasks function returns an array of 64-bit integers.  The array of 64-bit integers are the results of the two aggregates functions.
    • The first function returns the sum of the numbers.  The second function returns the square of the numbers.

The F# static method/function is shown below (Some familiarity with F# is required to understand what is going on, but I commented on the code for those unfamiliar with F#):

Now that we have this function (static method) defined in our F# library, it is ready to be used.  In the Silverlight application, we can add a reference to the F# library and then we can call the function (static method) as shown below in our C# Silverlight MainPage class.  Note that below we are calling the function just like we would call a static method with the [Name of Class].[Name of public function].  Notice also that because F# uses the base .NET type system, the returned array of integers does not need special casting/marshalling to C#.

Parallizing the Tasks

Now it is time to parallize the two tasks and scale it across multiple logical/physical processor cores.  As mentioned earlier, we are going to accomplish this with asynchronous workflows. In the figure below, I highlighted the changes to the function and it now scales across multiple cores.  This was done in two steps:

  • Wrap the body of the member functions with the async {... } syntax.
    • Add a return keyword (This signifies the return parameter/completion of the body).
    • The body of the function Seq.reduce addNumbers {0L..10000000L} now becomes async { return Seq.reduce addNumbers {0L..10000000L} }.
  • The main function (PerformTwoLongRunningTasks) now returns an array of async tasks.  These can be thought of delegates that need an Invoke-type command to execute them.  We simply change let results = [| task1; task2 |] to let results = Async.RunSynchronously (Async.Parallel [ task1; task2 ]).
    • All this does is tells the F# compiler to parallize these tasks.  However, run the result synchronously.  Therefore, the code returns to the main thread and we do not need dispatching/synchornization, etc.  This is analogous to creating a wait event in C# and having the two pieces of logic scheduled on secondary threads and waiting for this process to come back.

Asynchronous workflows allowed us to simply wrap the tasks as an "async function" declaratively.  This is a very important distinction as we just declared the logic and told it we want this to run in parallel.  Notice we didn't tell it "how to run in parallel" (imperative code).  Therefore, we did not have to:

  • explicitly start, stop threads (i.e., Thread.Start)
  • use BackgroundWorker
  • use callbacks (AsyncCallBack)
  • use BeginExecute asynchronous pattern

We simply told the code we want the tasks distributed among multiple cores and let the F# compiler figure out the hard part and generate the IL.  This is really powerful and in the very near future of "declarative parallel processing".  This is an example of what I mentioned earlier that the F# compiler has been designed recently and can include this type of "magic" right in the language.  C# does not have this feature and needs to be extended to provide this kind of automation.

Can't I do this with PLINQ?

Those familiar with the Parallel Extensions Libraries that will be added to .NET 4.0 might be aware that LINQ has been extended with parallelism features.  This allows you to extend your existing LINQ queries with parallism features.  This is known as PLINQ (parallel LINQ).  For example, a screen shot below shows a LINQ query that can be easily parallized by simply adding the AsParallel() extension method.

Unfortunately, the Parallel Extensions Library will NOT be available for Silverlight for the Visual Studio 2010 release.  However, I think that there is a good chance future versions of Silverlight will eventually get this feature.  There are some big features in the Silverlight assemblies that are simply missing and need to be added before features like PLINQ can be added.  This is exactly where asynchronous workflows can be substituted for PLINQ in a Silverlight application.  If you are working with large data sets, complex math computations, AI for a game, etc., parallelizing your code in F# libraries makes pefect sense for a Silverlight application.  This is MUCH easier than writing your own imperative multithreaded code.

How about the Performance?

I extended the functions and created functions for two, four and eight tasks and put this in a Silverlight application.  On my workstation (four cores), there was about a 50% improvement by parallelizing the two tasks.  With four tasks, the improvement in performance was about 3.5x.  As you can see, asynchronous workflows can easily dramatically improve the performance of your code on the Silverlight client.

Click the picture below to launch the demo application


Getting started with F#

Information on F# has been around for several years.  There are many articles, white papers, and books on F#.  However, you do have to be careful and get content that is recent and relative to the current F# release.  The F# specification has changed dramatically over the last several months as the language was being "productized" and many methods/functions simply don't exist in F# anymore.   Below are some links I put together where to get started.


  • Getting Started with F# - This video (from the 2008 PDC) is the place to start if you have zero F# experience and/or if you want a really good introduction into functional programming and some F# examples.

Books (I have read four different F# books and the two below are by far the best ones and most current.  Don Syme's F# book is good but a little outdated.)


  • This the main Microsoft F# page.  Includes numerours links, downloads for Visual Studio, F# extensions, etc.
  • Don Syme's blog - Don Syme is one of the main "creators" of F#.  His blog is a must read to get insight into advanced topics and upcoming F# news.


I hope this post gets Silverlight architects/developers exited about upcoming F# support.  F# is another tool that software architects can use that helps them create better software.  Furthermore, F# suport is another example of Microsoft's ability to integrate the Silverlight runtime across the .NET development stack.

kick it on
Posted: Nov 04 2009, 16:16 by Bart Czernicki | Comments (0) RSS comment feed |
  • Currently 0/5 Stars.
  • 1
  • 2
  • 3
  • 4
  • 5
Social Bookmarks: E-mail | Kick it! | DZone it! |