F# Weekly #50, 2012

17/12/201217/12/2012F# Weekly1 Comment

Welcome to F# Weekly,

A roundup of F# content from this past week:

News

Infer.NET 2.5 turns the simple succinct syntax of F# into a probabilistic modeling language for Bayesian machine learning. (video presentation)
Tomas Petricek presented “F# Data: Library for Data Access“.
David Siegel shared printf-style function for calling external programs with typesafe commandlines.
Paulmichael Blasucci pushed new version of fs-zmq (an F# binding for ØMQ)

Blogs & Tutorials

Daniel Mohl published “Using the New ASP.NET MVC 4 Template in MonoDevelop“.
Richard Warburton blogged “Are all Map Functions the same?“.
Steffen Forkmann presented “Testing, proving, checking – How to verify code properties“.
Steffen Forkmann presented “Using Footloose from F# – part I – Setting up the infrastructure“.
Srdjan Strbanovic blogged “Simple Continuous Integration with FAKE and windows scheduler F#“.
Jack Fox shared “Twitter and the F# Programming Community“.
Michael Newton posted a new blog post “Anyone Using FsCheck for Business Code?“.
Luca Bolognese blogged “LLite : language friendly literate programming“.
Kevin Berridge wrote about “Neat F#: Custom Operators“.
Tao Liu presented “Debug F# Type Provider“.
Faisal Waris blogged “Rich / Mobile Web Development – Without Losing Your Sanity“.

Upcoming events

That’s all for now. Have a great week and remember you can message me on twitter (@sergey_tihon) with any F# news.

Previous F# Weekly edition – #49

F# Weekly #49, 2012

10/12/2012F# Weekly1 Comment

Welcome to F# Weekly,

A roundup of F# content from this past week:

News

Tomas Petricek shared examples of “Charting World Bank data with F#“.
F# 3.0 is now part of Mono 3.0.2 bundle on Mac.
New section “Math Stacks for F#” was published on The F# Software Foundation.
Keith Sheppard announced “An F# binding for LLVM“.

Blogs & Tutorials

Tao Liu published “F# Computational Expression Sample – File System + XML“.
James Litsios blogged “Introduction to stateful monads“.
Ted Neward on The Advantages of F#.
Tomas Petricek shared a presentation “How F# Learned to Stop Worrying and Love the Data“.
Luca Bolognese blogged “Exceptions vs. Return Values to represent errors (in F#) – IV – Implementation“.
Don Syme presented “QuickLinq Helpers“.
Don Syme published “F# Community Update“.
Daniel Mohl wrote of “Using the New ASP.NET MVC 4 Template in MonoDevelop“.
Richard Warburton blogged “Are all Map Functions the same?“.
Zach Bray published “Building an “actor” in F# with higher throughput than Akka and Erlang actors“.
Tao Liu presented “Remove F# snippet shortcut“.

That’s all for now. Have a great week and remember you can message me on twitter (@sergey_tihon) with any F# news.

Previous F# Weekly edition – #48

F# Weekly #48, 2012

03/12/2012F# Weekly1 Comment

Welcome to F# Weekly,

F# shines like a diamond in the daily coding routine. Piece of that shine from this past week:

News

Zach Bray announced FunScript. (F# to JavaScript compiler with JQuery etc. mappings through a TypeScript type provider)
The Nuget team fixed the F# compatibility bugs. You can use the nightly build.
F# works with MonoDroid.(more details)
Voting began for better F# support in NuGet.

Blogs & Tutorials

Tao Liu published “F#/C# on Algorithms – Poisson Distribution“.
Justin James blogged “Try F# site: A top-notch programming resource“.
Dave Thomas shared a post “MonoGame 3D Basics“.
Matthew Doig wrote of “Json and the F# Type Provider“.
Dave Fancher shared “F# Record Types“.
Loic Denuziere wrote about “Building UIs for WebSharper with ExtJS Architect“.
Igor Kulman published “Fun with F# Type Providers: SQL“.
Don Syme posted “Math.NET Numerics v2.3.0 released, with improved F# support“.
Jack Fox shared “FSharpx Data Structures Discussion“.
Tao Liu presented “F# on Algorithms – Wagner–Fischer algorithm“.
Luca Bolognese blogged “Exceptions vs. Return Values to represent errors (in F#) – III–The Critical monad “.
Pezi published “Monads to help with COM cleanup“.
George Stavroulakis presented “F# in the Cloud with {m}brace“.
Mathias Brandewinder blogged “Using FSI to execute F# code from a .NET app“.

Upcoming events

F# meetup in San Francisco “Building a customizable business rules engine with F#“.

That’s all for now. Have a great week and remember you can message me on twitter (@sergey_tihon) with any F# news.

Previous F# Weekly edition – #47

SharePoint 2013 Development Environment

26/11/201226/11/2012Enterprise Search, SharePoint1 Comment

Talbott Crowell's Software Development Blog

In this post, I’m going to describe my setup and some of the software and system requirements I needed for getting a SharePoint 2013 development environment up and running. I’ll try to update this post as new releases of the Microsoft Office Developer Tools for Visual Studio 2012 are released or I make major changes or discoveries as time progresses.

Development Environment Setup

I’ve been using CloudShare for some of my SharePoint 2013 development ever since I purchased my new MacBook Air 11 inch which is maxed out at 8 GB and running Parallels so I can run Windows 7. But recently I’ve decided to pull out my old Dell Precision M6500 laptop which has 16 GB to get a SharePoint 2013 development environment set up locally. This beast is a great laptop for SharePoint development, but it is very heavy (the power supply is heavier then my MacBook Air). …

View original post 1,930 more words

F# Weekly #47, 2012

26/11/2012F# Weekly2 Comments

Welcome to F# Weekly,

A roundup of F# content from this past week:

Blogs & Tutorials

Gaston Hillar posted “Functional Programming in the Financial Industry“
Dave Fancher wrote of “F# Interactive (FSI)“.
Daniel Mohl blogged “F#, ASP.NET MVC, and MonoDevelop“.
Tao Liu published “C# async and F# async“.
Kolja posted “event driven webserver with F#“.
Phillip Trelford shared “F# as a Unit Testing Language“.
Adam Granicz opened the veil of secrecy over F# Cloud IDE.
Luca Bolognese blogged “Exceptions vs. Return Values to represent errors (in F#) – I – Conceptual view“.
Luca Bolognese blogged “Exceptions vs. Return Values to represent errors (in F#) – II– An example problem“.
Dave Fancher posted “F# Tuples“.
Michael Newton shared “Representing EasyNetQ Message Subscriptions as Blocking Queues“.
Michael Newton wrote about “Strange errors from the F# compiler“.
Adil Akhter shared a video “A Practical Developer’s Introduction to F#” by Ivan Towlson.
Jack Fox blogged “Simple Lookups in F#, Choices and Trade-offs“.
Cameron Taggart presented “1st build of an F# Type Provider for .proto files“.
Richard Minerich shared a paper “Supervision – F# for Static Analysis“.
Don Syme posted “Try F# 3.0 – Get Your Feedback In Now!“.

Resources & Books

Tim Robinson presented “F# Notebook“.
New Math.NET Numerics v2.3.0 released.
New section “Web Stacks for F#” published on the F# Software Foundation.

Upcoming events

F# speech at TechEd Russia (Agenda.pdf).
Don Syme will give a talk on F# in the open source world. 😉
{m}brace the cloud project, video conference presentation.

That’s all for now. Have a great week and remember you can message me on twitter (@sergey_tihon) with any F# news.

Previous F# Weekly edition – #46

F# Weekly #46, 2012

19/11/201219/11/2012F# Weekly3 Comments

Welcome to F# Weekly,

It’s time to read Mission Statement and join F# Software Foundation! Now you can enjoy new portion of F# weekly:

Blogs & Tutorials

Mathias Brandewinder posted “Kaggle/StackOverflow contest field notes, part 1“
Jack Fox blogged “Let’s Make a Bayesian Deal“.
Tao Liu published “Word Document Type Provider“.
Sergey Tihon wrote about “My wish list for FSI“.
Yan Cui presented “DynamoDb.SQL – a SQL-like external DSL for Amazon DynamoDB“.
“Types vs. Tests: An Epic Battle?” presented by Amanda Laucher, Paul Snively.
Sergey Tihon posted “Accessing Local Variable Information in FSI“.
Michael Newton shared “Representing EasyNetQ Message Subscriptions as Blocking Queues“.
Tao Liu presented “F# Seq.unfold for recursive structure“.
Ruslans shared “Mahjong solitaire puzzle game in F#/WPF“.
Dave Fancher posted “Introducing F#“.
Dave Fancher wrote of “F# Primitives“.
Fisnik Hasani blogged “Introducing the F# Programming Language“.
Phillip Trelford shared a presentation “F# for Trading“.
Dave Fancher posted “F# Basic Units of Measure“.
Tao Liu shared a post “Seq.unfold and recursive“.
Dave Fancher published “F# More On Units of Measure“.
Phillip Trelford ‏announced Foq a Mocking library for F#.

Resources & Books

Expert F# 3.0 is out!!! By Don Syme , Adam Granicz , Antonio Cisternino.
New book “Friendly F#” by Giulia Costantini and Giuseppe Maggiore.
New book “Building Web, Cloud, and Mobile Solutions with F#” by Dan Mohl.
New book “F# for C# developers” by Tao Liu.

That’s all for now. Have a great week and remember you can message me on twitter (@sergey_tihon) with any F# news.

Previous F# Weekly edition – #45

Accessing Local Variable Information in FSI

15/11/2012F#1 Comment

It’s time to make first steps to the new improved FSI. I feel that I should start looking for ways to implement something from My wish list for FSI. Let’s begin from #3 and try to find a list of declared variables and functions.

Before execution of any piece of code, FSI compiles it and creates a new type in current assembly. This type contain all named variables as properties and named function as function. The latest unnamed variable/function stores in property that called ‘it‘. So, it means that we can collect all required information using reflection.

Below you can find my implementation of the function objects() that prints lists of declared variables and functions.

let objects() =
  let methods =
    System.Reflection.Assembly.GetExecutingAssembly().GetTypes()
      |> Seq.filter (fun t ->
        t.CustomAttributes |> Seq.exists (fun a ->
          a.AttributeType = typeof<Microsoft.FSharp.Core.CompilationMappingAttribute>))
      |> Seq.sortBy (fun t -> t.Name)
      |> Seq.map (fun t ->
        t.GetMethods() |> Seq.filter(fun m -> not(m.IsHideBySig)))
      |> Seq.concat
      |> List.ofSeq
  let var, func =
    Map.empty<string, System.Reflection.MethodInfo>
      |> List.foldBack (fun (m:System.Reflection.MethodInfo) map ->
              let name = if (not(m.IsSpecialName)) then m.Name
                         else m.Name.Substring(4)
              if ((m.IsSpecialName && (m.GetParameters().Length > 0)) ||
                  map.ContainsKey(name)) then map
              else map.Add(name, m))
         methods
      |> Map.toList
      |> List.partition (fun (_,m) -> m.IsSpecialName)

  let printList title ls =
    printfn "%s : %A" title ( ls |> List.map fst |> List.sort )
  var  |> printList "Variables"
  func |> printList "Functions"

Now let’s look at a real-life example on the screenshot below.

My wish list for FSI

14/11/201214/11/2012F#6 Comments

I have thought about possible directions of FSI development. I have some ideas that I would like to share and discuss.

In general, it would be great to make FSI more than just an execution shell. It can become a really powerful development tool. What exactly we can do:

1) Session Save/Load functionality

It will be nice to have an ability to save current FSI state into the file and continue work in the next time.

2) Native C# interaction with FSI saved sessions

It could sound crazy, but it would be cool to save FSI session to assembly and provide an easy C#-F# interaction with such assemblies. For example, it might be useful for Machine Learning tasks. You will be able to create, train and tune your model directly from FSI then save it to assembly and use it from your C# application.

3) Current environment overview

Provide an ability to see the difference between current FSI state and default state. For example:

Print all declared variables with their values
Print all declared function with their signatures
Print list of referenced assemblies with included directories
Provide an ability to print function’s body

There is a tool that provides a part of this functionality. This is FsEye – a visual object tree inspector for the F# Interactive.

4) Intellisense for FSI

5) Detailed type provider description

One of the main cons in type providers is impossibility to explore the schema of the provided world. For example, I want to use Freebase type provider, but I do not know the nature of the provided types. I cannot use provided types fully, because I do not know what data they have.

I am pretty much sure that we need to supply a way to explore provided types. This feature for sure should be tightly integrated with F# IDEs (into Object browser for example).

6)Interactive help

All we use MSDN to understand how things work. We copy type name + function name and paste them to Google, find first MSDN link and go there. Why cannot we teach FSI to do it? We just need to build an easy syntax for that.

7) The ability to use the load directive inside of modules\functions (by @davidkl_)

P.S. I will be happy to hear your feedback or new ideas. Feel free to post comments here or to contact me in twitter (@sergey_tihon).

F# Weekly #45, 2012

12/11/201212/11/2012F# Weekly4 Comments

Welcome to F# Weekly,

Enjoy F# reading list from this past week.

Blogs & Tutorials

Phil Trelford blogged “Progressive F# Tutorials London 2012“.
Daniel Mohl shared presentation “Building Better Web Apps with F#“.
Jack Fox published “The Miracle of F# Continuation Passing“.
Bryn Keller wrote about “Transactional Objects“.
Phillip Trelford and Tomas Petricek hosted a discussion on their efforts to establish the F# Software Foundation to demonstrate and promote the use of F# across platforms. (Video by Ryan Riley).
Sergey Tihon shared a post ““F# Weekly” under the hood“.
Tao Liu presented “F# on Algorithms – Neural Network“.
Michael Newton shared “An introduction to F# (Screencast and PDF slides)“.
Johannes Rudolph blogged “F# 3.0 on AppHarbor“.
Tao Liu published “F# >= C# (Pattern matching)“.
Tao Liu wrote of “F# Memorization on Recursive Function“.
Jon Harrop posted “Trying to get F# working on the Raspberry Pi“.
Dave Thomas shared a post “F# and MonoGame on the Mac“.

Resources & Books

Taha Hachana presented a Open Source SEO Tool.
Phil Trelford published Mini Rx on CodePlex.
New F# Software Foundation site was released.

Upcoming events

Don Syme speaking on F# 3.0 in Mountain View.

That’s all for now. Have a great week and remember you can message me on twitter (@sergey_tihon) with any F# news or use hashtag #fsharpweekly.

Previous edition of the F# Weekly – #44