http://bogdanbrinzarea.files.wordpress.com/2010/07/20100225-f-let-the-fun-begin-part-2-bogdan-brinzarea.pptx

Enjoy,

Bogdan

Please join me again on Thursday for the second part of the introduction to F# where we will talk about asynchronous and parallel programming and unit testing.

Below, you can find the slides of yesterday’s session.

20100222 F# Let the fun begin – part 1 – Bogdan Brinzarea

Enjoy,

Bogdan

http://ctocorner.com/fsharp/book/

I think it represents a great starting point for learning F# as it covers very well the main features of the language.

Enjoy,

Bogdan

Official resources

Core Library reference http://msdn.microsoft.com/en-us/library/ee353567(VS.100).aspx

Language Reference http://msdn.microsoft.com/en-us/library/dd233181(VS.100).aspx

Language Specification http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/spec.html

http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/

http://msdn.microsoft.com/fsharp

F# presentations

http://www.slideshare.net/mrkurt/f-presentation-1270431

http://blogs.msdn.com/dsyme/archive/2009/10/10/f-tutorial-code-and-slides-jaoo-2009-edition.aspx

http://blogs.msdn.com/lukeh/archive/2010/02/01/f-for-parallel-and-asynchronous-programming-pdc-2009.aspx

http://blogs.msdn.com/dsyme/archive/2006/11/22/f-presentation-at-czech-net-group-meeting.aspx

http://blog.cwa.me.uk/2008/05/18/f-presentation-slides-and-demos/

http://cs.hubfs.net/files/27/public_presentations/entry30.aspx

http://weblogs.asp.net/podwysocki/archive/2008/07/10/aspects-of-functional-programming-in-c-presentation-and-code.aspx

http://channel9.msdn.com/pdc2008/TL11/

http://www.slideshare.net/mattpodwysocki/async-and-parallel-f-1825975#

Tutorials

Matthew Podwysocki

http://weblogs.asp.net/podwysocki/archive/2008/03/06/adventures-in-f-f-101-part-1.aspx

http://weblogs.asp.net/podwysocki/archive/2008/03/06/adventures-in-f-f-101-part-2.aspx

http://weblogs.asp.net/podwysocki/archive/2008/03/06/adventures-in-f-f-101-part-3.aspx

http://weblogs.asp.net/podwysocki/archive/2008/03/06/adventures-in-f-f-101-part-4.aspx

http://weblogs.asp.net/podwysocki/archive/2008/03/17/adventures-in-f-f-101-part-5-pattern-matching.aspx

http://weblogs.asp.net/podwysocki/archive/2008/03/21/adventures-in-f-f-101-part-6-lazy-evaluation.aspx

http://geekswithblogs.net/Podwysocki/archive/2008/04/03/121002.aspx

Brian McNamara (Inside F#)

http://lorgonblog.spaces.live.com/blog/cns!701679AD17B6D310!1603.entry

http://lorgonblog.spaces.live.com/blog/cns!701679AD17B6D310!1612.entry

http://lorgonblog.spaces.live.com/blog/cns!701679AD17B6D310!1767.entry

http://lorgonblog.spaces.live.com/Blog/cns!701679AD17B6D310!1778.entry

Tomas Petricek

http://tomasp.net/articles/fsharp-i-introduction.aspx

http://tomasp.net/articles/fsharp-ii-functional.aspx

http://tomasp.net/articles/fsharp-iii-oop.aspx

http://tomasp.net/blog/fsharp-iv-lang.aspx

Chris Smith

http://blogs.msdn.com/chrsmith/archive/2008/05/02/f-in-20-minutes-part-i.aspx

http://blogs.msdn.com/chrsmith/archive/2008/05/09/f-in-20-minutes-part-ii.aspx

Dustin Campbell

http://diditwith.net/2008/01/15/WhyILoveFTheInteractiveEnvironment.aspx

http://diditwith.net/2008/01/18/WhyILoveFTuples.aspx

http://diditwith.net/2008/01/21/WhyILoveFBreakingUpTuples.aspx

http://diditwith.net/2008/01/29/WhyILoveFResultTuples.aspx

http://diditwith.net/2008/01/30/WhyILoveFFunctionsFunctionsFunctions.aspx

http://diditwith.net/2008/02/19/WhyILoveFPatternMatching.aspx

http://diditwith.net/2008/02/25/WhyILoveFOptionTypes.aspx

http://diditwith.net/2008/03/03/WhyILoveFListsTheBasics.aspx

http://diditwith.net/2008/03/14/WhyILoveFARefactoringTale.aspx

Enjoy,
Bogdan

In the past 6-7 years, Microsoft Research has prepared F# (http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/) with OCaml at its core and I thought it is worth giving it a try.

Things went great and I actually used F# to implement a financial algorithm for a large set of data (hundreds of millions of records).  As F# is a compiled language that benefits from all of the functional programming features and from the interoperability with other .NET languages (C#, VB), I think using it in some scenarios could represent a great benefit.

In the next period I will have more posts about F# as it currently represents one of my main interests.

On the 22nd and 25th of February I will have two online sessions for Microsoft Romania (http://www.microsoft.com/romania/evenimente/) talking about the main features of F#.

Stay tuned for more!

Bogdan

AJAX and PHP - Building modern web applications - 2nd edition

Overall, I think this edition adds new value having a focus on Object Oriented Javascript including JQuery. Patterns also play an important role and have their own chapter.

Enjoy,
Bogdan

Ayende has (yet) another really enlightening post about the issues with the classic three layers (tiers) applications.

DDD

Jonathan Oliver has another great post about storage of events.

C#

Eric Lippert has a very nice post clearing some of the doubts people might have around precedence operator and order of operations.

ASP.NET MVC

Joe Stagner points out a DotNetSlackers project that aims to clone StackOverflow.com. In the process they will use: CruiseControl.Net, NAnt, NUnit, RhinoMocks, NDepend, NCover, NDoc, ASP.NET MVC 2.0, LINQ to SQL, StructureMap, AutoMapper, Elmah, Velocity, MemCached. Keep an eye on what promises to be a very cool open source project!

Entity Framework

Alex James published two more tips:

• Tip 31 – How to compose L2O and L2E queries
• Tip 32 – How to create a database from SSDL – EF 4 only

Julie Lerman has a very nice article about table splitting as the opposite of entity splitting.

TDD

Daniel Cazzulino shows how the power of LINQ is integrated in the next version of Moq.

Simone Chiaretta dissects the DropDownList helper method.

David Hayden continues his post from yesterday showing how we can separate the validation annotations into a metadata class via BuddyMetadataProvider similar to how DynamicData works.

C#

Daniel Cazzulino shows how to achieve strongly typed reflection for generic types and methods by creating a delegate of the target method and using the delegate’s properties to get the corresponding MethodInfo.

The CLR team talks about IL Stubs Everywhere feature in C# 4.0 that allows the same IL stubs infrastructure for all marshalling on all platforms.

Bart DeSmet presents the new System.Linq.Expressions namespace in C# 4.0.

Design patterns

Jeremy Miller announces that the presentation patterns wiki is live!

DDD

Jonathan Oliver has an excellent post about distributing a single bounded context on different machines and dealing with optimistic concurrency.

Entity Framework

Julie talks about entity properties that we can take advantage of in EF 4.0 and that are designed for model first and dynamic data support.

RIA

Fredrik Normen shows how SubmitChanges mechanism works in .NET RIA Services.

Unity

Mike Taulty has a nice post about Unity’s features.

David Hayden shows how the support for System.ComponentModel.DataAnnotations in DefaultModelBinder works in ASP.NET MVC 2.0 Preview 1.

Entity Framework

Julie Lerman talks about code only support and query improvements in EF 4.0.

Alex James talks about structural annotations.

MEF

Bart DeSmet has an excellent introductory post about MEF.

In the latest MSDN Magazine, David Simmons talks about N-Tier Application Patterns and Tim Mallalieu talks about Data Access Architecture Best Practices.

Simon Seagal has an interesting post about fetching strategies in EF 4.0. Also Alex James has a nice post about implementing fetching strategies.

Mattieu Mezil show how to use TypeDescriptors to make FK work in EF 1.0.

In his 30th tip, Alex James shows how to use database functions in EF 1.0 and EF 4.0.

The ADO.NET team presents the improvements to the generated SQL for Entity Framework.

ASP.NET MVC

Phil Haacked shows how to focus in View pages on presentation concerns by moving Page declaration to web.config. He also shows a prototype of default templated views that we might have in the future bits of MVC.

C#

Kirill Osenkov points out the C# compiler team blogs.

Chris Burrows has a nice post about dynamic base classes.

Eric Lippert has another bunch of excellent articles:

• Generics are not templates
• Scope vs Declaration Space vs Lifetime
• Iterator blocks Part Four: Why no yield in catch?
• Iterator Blocks, Part Five: Push vs Pull
• Iterator Blocks, Part Six: Why no unsafe code?
• Not everything derives from object