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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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#.
- Lambda Syntax - If you are familiar with lambda syntax in C#, you will see a very similar lambda syntax in F#.
- Extension Methods - This could be associated with knowing LINQ but it is worth mentioning here as extension methods are essential in "fluent" code.
- 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#.
- 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#.
- 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!!)
- 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.
Summary
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.
Videos
- 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.)
Websites
- http://www.fsharp.net/- 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.
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.
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:
- Log in to http://sql.azure.com with your account information
- Go to the SQL Azure tab to access your projects (If one doesn't exist, create one.)
- Click on the project row to access the SQL Azure Server Administration screen.
- If you do not have a server SQL Azure server provisioned, you will be asked to create one.
- In the SQL Azure Administration Screen you can
- Drop/Re-create a server
- Reset the admin password
- Get a connection string to the database server
- Test the server connection (send a connection ping)
- Manage your databases
- Change the Firewall Settings
- 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.
- 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.
- 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.
- 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.
- In order to fix this, we simply need to allow the IP address you are connecting from in the Firewall Settings manager.
- 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.
- 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:
- 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.
- If you have an ISP that has a dynamic list of IPs, enter the IP range that was provided to you.
- This is NOT recommended, but you could add a rule that opens up the entire IP stack of the Internet by entering 0.0.0.0 -> 255.255.255.255
- 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.
- 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.
- 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)
Conclusion
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.
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.
Videos
- 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.)
Websites
- http://www.fsharp.net/- 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.
I have been excited about Silverlight since Silverlight 1.1 Alpha was announced in early 2007. I have seen tremendous potential in the RIA technology from its inception. Being through the .NET 1.0 release in 2002 and seeing how Microsoft can make a powerful framework that can integrate with across their products made me feel secure that Silverlight was going to get full integration support by Microsoft. Fast forward to 2009 and we are in the third release of Silverlight. Silverlight has evolved tremendously and has caught up feature-wise with Adobe's RIA products (Flash, Flex, AIR) and is ahead in some features. If you have been following this blog or my identity online, you are aware I am very passionate about the technology well beyond a Flash alternative. I think Silverlight often gets compared to other RIAs and does not properly distinguish its attributes that make it a great business RIA. Features like enterpise service integration (WCF, .NET RIA Services), HD Smooth Streaming, SharePoint (web parts), Bing SDK/Map integration, cloud computing (Azure), mobile, parallel computing, etc., are not amplified enough.
One of my complaints is that the message of what this technology can accomplish in a business environment is currently being under-represented by the online community and Microsoft. It is easy to find an article on how to do a flip animation or bind to a datagrid. However, I think Silverlight needs to be represented better as a busines tool and how the RIA architecture can be applied to solve real business problems. Take a look at the list of books available for Silverlight (http://www.silverlightshow.net/Books.aspx). Looking at the list, you will notice that a majority of the books are essentially intros to Silverlight features. Some of the books have different names, but essentially you are not getting an application of the technology to solve business scenarios. Don't get me wrong; some of the books I have read truly stand out (i.e., John Papa's Data Driven Services, SharePoint Dev using Silverlight, Jeff Paries's Foundation Silverlight Animation) and go well beyond listing object properties and show you how to apply advanced engineering concepts using Silverlight. However, I saw an opportunity to provide a resource that shows how Silverlight can be applied to solve business problems.
Over the last two years, I have had the opportunity to use Silverlight in the enterprise and saw its potential for delivering Business Intelligence (BI) solutions. Silverlight's ability to execute on the client and deliver visual intelligence makes it a fanastic option to surface interactive Business Intelligence analytical modules. I decided to combine my experience of designing Business Intelligence solutions and apply these principles to Silverlight in a new book. After about six months of work, I am pleased to announce my book Next Generation Business Intelligence Software with Silverlight 3. The book will be available in the October/November timeframe and is currently listed as a pre-order on Amazon, Barnes and Noble, etc.
What will you learn from investing in this resource?
Covering the entire scope of BI and applying these concepts to Silverlight applications is simply not realistic in one single resource. Even if I had the option of writing 750 pages or more, important facets of BI would be missed. Therefore, I decided to focus on the presentation tier of Business Intelligence applications. For example, I didn't think it was fair to focus on the data and services tier with these technologies going through a rapid implementation and tooling evolution (RIA Services, WCF REST, Oslo, ADO.NET Data Services 1.5, etc.). However, Silverlight's rendering and client processing engine is mature enough to warrant a guide on how to implement client-side BI concepts. Therefore, topics like visual intelligence, data visualizations, predictive analytics, collective intelligence, interactive tools, parallel computing, working with large data sets, etc., are covered in my book on the presentation tier.
Who is this book for?
This book has three intended audience segments and their goals:
- Silverlight Developers - Learn how to extend your Silverlight knowledge in real-world applications. Learn the basics of Business Intelligence 2.0.
- Business Intelligence Professionals - Get a better understanding of how Silverlight can help you overcome some of the challenges to implement simple BI tools.
- Strategic Decision Makers (architects, CIO, technical director, etc.) - Understand if Silverlight is the right platform to deliver BI software.
What is the chapter list?
- The first chapter (Business Intelligence 2.0 Defined) is an introductory chapter to Business Intelligence. This chapter will introduce BI and the new wave of BI 2.0. The content will show how Business Intelligence is evolving and embracing new software development advancements. This chapter will contrast classic BI and BI 2.0 by showing numerous examples of current software offerings. Lastly, this section will define the core items of BI 2.0 which will be implemented throughout this book using Silverlight.
- The second introductory chapter (Advantages of Applying BI 2.0 Using Microsoft Silverlight) introduces the Microsoft RIA technology: Silverlight. This chapter is dedicated to analyzing the current Microsoft Business Intelligence product vertical and providing opinions why Silverlight is a good fit for implementing Business Intelligence tenets. After reading this chapter, you will understand the key enterprise and business integration features of Silverlight that will be discussed in this resource.
- Chapter Three (Silverlight as a BI Client) looks at what makes an effective BI client. It goes on to specifically detail Silverlight tools and features that can be used to create a fantastic functioning analytical experience. The chapter goes into specific functionality such as LINQ data queries, business algorithm implementations and local storage.
- In Chapter Four (Adding Interactivity to BI Data), the information from the previous chapters is used to show how to use Silverlight to bring interactivity to BI applications. This chapter will teach by example on how to add simple interactions that can make a BI client easier to use and feel more fluid. It concludes with how these concepts can be leveraged for future designs with multi-touch screens to create the ultimate interactive experience.
- Chapter Five (Introduction to Data Visualizations) is the first chapter in a series of chapters about Visual Intelligence. The content in this chapter will show the empirical advantages of creating a visual representation of data versus classic tabular layouts. This chapter shows how visualizing data has matured and grown over the last several years. The concept of natural visualizations is introduced by defining the different characteristics and Silverlight implementations.
- Chapter Six (Creating Data Visualizations for Analysis) continues to build on the visual intelligence topic by showing how to enhance data visualizations with features to make turn them into analytical tools. This chapter will show you how to create advanced visualizations by extending the default Silverlight data visualization presentation.
- Chapter Seven (Enhancing Visual Intelligence in Silverlight) is the last chapter that focuses on creating complex composite data visualizations. You will also see how Silverlight as a professional visual intelligence environment can implement BI 2.0 functionality.
- Chapter Eight (Applying Collective Intelligence) introduces collective intelligence as a form of social Business Intelligence. This chapter defines the importance of Collective Intelligence on the web today. Furthermore, you will see how Silverlight can be used to gather and surface Collective Intelligence to users.
- Chapter Nine (Predictive Analytics) will describe how to integrate forward-looking data structures in our client logic to perform "what-if" scenarios. This chapter will also show how statistics used on aggregates can deliver instant insight on future events.
- Chapter Ten (Improving Performance with Concurrent Programming) is an advanced chapter that covers additional enhancements that can be gained by using multiple cores to aid in BI calculations. You will see how you can enhance the performance of BI modules by leveraging Silverlight’s advanced CPU and GPU programming features.
- Chapter Eleven (Integrating with Business Intelligence Systems) is a chapter that shows you how to apply the concepts that you have learned and integrate them into new solutions or existing BI systems. Silverlight in an SaaS delivery model as well as Silverlight web parts are covered in this chapter.
- Appendix A (Prototyping Applications with Dynamic Data) includes a short primer on prototyping data applications in Microsoft Expression Blend 3. This short section provides a quick overview on how to use Blend’s dynamic data feature to quickly create and add data to UI functionality without having to spend time architecting databases and services. This is a powerful tool to prototype BI 2.0 analytical modules without needing access to large-scale data repositories.
Companion Web Site
In addition to providing the source code and samples with this book, I have decided to create a companion web site for this resource. I don't think it would be fair for me to claim that this book can be fully understood by non-Silverlight developers if all that was provided was a zip file with source code. The companion web site will include all of coding scenarios as live demos which will allow readers without the full Silverlight development environment to fully understand the content. Furthermore, it will include the source code and samples that were not covered in detail in the book. I plan to use the companion web site as a vehicle to deliver further information on Business Intelligence and Silverlight in the form of web resource links, training videos, whitepapers and more advanced examples. I am currently working on the companion web site and it will be launched when the book is closer to being published.
If you are a Silverlight developer or interested in Business Intelligence, I encourage you to give my book a try to see how visual and interactive analytical tools can be delivered to average users with Silverlight.
Sample Content of What You Will See In This Book
Creating a Silverlight Predictive Analytics Tool to estimate future sales revenue
Optimizing Data Processing with Concurrent Programming (looks scary; it really isn't)
Learn about distributive client-side architecture for BI
Silverlight as an enterprise Visual Intelligence Environment (Trellis Data Visualization with KPI goals)
Don't worry if this is all alien to you...I will walk you through BI 2.0 fundementals as well...
Silverlight 3 has been released here are some of the released links:
Silverlight 3 Runtime
http://www.microsoft.com/silverlight/resources/install.aspx
Blend 3 with Sketchflow
http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=92e1db7a-5d36-449b-8c6b-d25f078f3609
SDK
http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=2050e580-f1d5-4040-bb09-e6185591b6b5
VS 2008 Tools
http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=9442b0f2-7465-417a-88f3-5e7b5409e9dd
.NET RIA Services (July 2009)
http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=76bb3a07-3846-4564-b0c3-27972bcaabce
Silverlight Control Toolkit (July 2009)
http://silverlight.codeplex.com/
Change list of the Silverlight Control Toolkit: http://silverlight.codeplex.com/Wiki/View.aspx?title=Silverlight%20Toolkit%20July%202009%20change%20list
DeepZoom Composer
http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=457b17b7-52bf-4bda-87a3-fa8a4673f8bf
Seven Additional Navigation Themes
http://timheuer.com/blog/archive/2009/07/09/free-silverlight-application-themes-silverlight-3.aspx
Still waiting on these:
- Bing Enterprise Map Control for Silverlight (currently in CTP)
- ADO.NET Data Services (currently 1.5 CTP)
- Prism Update (saw some blog post MVVM templates they were adding to the framework)
- Visual Studio 2010 Beta 1/2 tools for Silverlight 3 RTW
- Other (Silverlight Mobile maybe (?), XBOX Developer Add-Ons etc.)
Installation notes for developers:
- You need to uninstall EVERYTHING Silverlight developer related to get it to work: Silverligh 3 SDK, Visual Studio 2008 Tools, Blend 3 Beta. Otherwise you will get a message saying your developer tools are out of date.
- Silverlight Control Toolkit March 2009 will not work with Silverlight 3 RTM
- Expression Blend 3 is NOT RTM it is apparently RC (Update: the version out now is RC, which will work with Silverlight 3 RTM. Expression Studio 3 RTM is shipping within the next 30 days.)
- When you upgrade your projects from Silverlight 2/3 Beta to Silverlight 3 RTM make sure you have the correct assemblies referenced! Note some controls have moved from the SDK to the Control Toolkit and vice versa.
Installation Order (if you have Visual Studio 2008 SP1)
- VS 2008 Silverlight Tools (installs the runtime, SDK as well)
- Expression Blend 3 Trial
- .NET RIA Services
- Silverlight Control Toolkit
Installation notes for casual users:
- Your users will automatically be upgraded to Silverlight 3 (if they have the auto update selected, which is the default).They can always upgrade manually.
- If you are developing a product on Silverlight 2, you should turn off automatic updates of the runtime...just in case.
