F# Weekly #6, 2016

Welcome to F# Weekly,

A roundup of F# content from this past week:

News

Videos/Presentations

Blogs

Ernest Pazera coding corner

F# vNext News 

Open source projects

  • Gluon – A type-safe remoting connector between an F# backend and a TypeScript client
  • FsGll – A parser combinator library based on the GLL algorithm for F#
  • Delegate.SPOcopy – A library that copies a local folder, including files and subfolders (recursively), to SharePoint Online, ensuring valid SharePoint relative url names.
  • stockestimator – F# library for estimating future stock prices
  • phutball-fs – Phutball game in F#
  • fsraster – A simple image-processing and primitive-rendering app in F# and WPF

New Releases

That’s all for now. Have a great week.

Previous F# Weekly edition – #5Subscribe

F# Weekly #5, 2016

Welcome to F# Weekly,

A roundup of F# content from this past week:

News

Videos/Presentations

Blogs

Ernest Pazera coding corner

F# vNext News 

Open source projects

  • MITIE-Dot-Net – A Nice .NET Wrapper for the MITIE Information Extraction Library
  • tjofgd-project1 – The Joy of Functional GameDev – Project #1
  • BS – Implementation of the BS language as created by Mark Rendle at BuildStuff.lt 2014. Refer to this repo for information and canonical list of language features
  • FsAkkaWeb – POC of using Akka + F# on the web with ASP.NET MVC5
  • fsuno – Event sourcing implementation sample in F#

New Releases

That’s all for now. Have a great week.

Previous F# Weekly edition – #4Subscribe

F# Weekly #4, 2016

fsharpConf
Welcome to F# Weekly,

A roundup of F# content from this past week:

News

Videos/Presentations

Blogs

Ernest Pazera coding corner

F# vNext News 

Open source projects

New Releases

That’s all for now. Have a great week.

Previous F# Weekly edition – #2#3Subscribe

F# Weekly #2-#3, 2016

Welcome to F# Weekly,

A roundup of F# content from past weeks:

News

Videos/Presentations

Blogs

Ernest Pazera coding corner

F# vNext News 

Open source projects

  • suave-angular2-demo – Demo site for Suave 1.0 + Angular 2.0.0-beta.0
  • emparsec – Embeddable single file parser
  • FsSql – Functional wrapper around ADO.NET for F#
  • spiral-library – Basic reverse AD on the GPU
  • generator-fsharp – Yeoman generator
  • fing – F# API Search
  • fix – Project and File Management for F#
  • ScrapyFSharp – This is a reborn of Scrapysharp written in FSharp
  • vsts-fsharp – Visual Studio Team Services extension for F#-friendly tools
  • unquote – Write F# unit test assertions as quoted expressions, get step-by-step failure messages for free
  • FunSharp – Fun cross-platform graphics library, based on the Small Basic library, made specifically for F# and C#.
  • FSharpVerbalExpressions – F# Regular expressions made easy
  • ILBuilder – Prototype for an F# MSIL DSL

New Releases

That’s all for now. Have a great week.

Previous F# Weekly edition – #1Subscribe

F# Weekly #1, 2016 – New Year Edition

HNY2016Welcome to F# Weekly,

Thank you to all who participated and read this year “F# Advent Calendar in English 2015“. We did it once again and it was amazing!!!

A roundup of F# content from this past week:

News

Videos/Presentations

Blogs

F# vNext News 

Open source projects

New Releases

That’s all for now. Have a great week.

Previous F# Weekly edition – #52Subscribe

F# Weekly #52, 2015

Welcome to F# Weekly,

A roundup of F# content from this past week:

News

Videos/Presentations

Blogs

F# vNext News 

Open source projects

New Releases

That’s all for now. Have a great week.

Previous F# Weekly edition – #51Subscribe

F# Weekly #51, 2015

Welcome to F# Weekly,

A roundup of F# content from this past week:

News

Videos/Presentations

Blogs

F# vNext News 

Open source projects

  • Aether – an open source optics (lenses, prisms, etc.) library for F#
  • Chiron – an open source library for working with JSON in F#
  • XrmContext – generates early-bound .NET framework classes which represent the entity model of the given Dynamics CRM instance
  • ServiceFabricSuave – Minimal Suave Host for Azure Service Fabric
  • FsOwin – an example of an F# OWIN API
  • ifsharp – F# Profile for iPython Notebook 1.x and 2.x
  • fhash – File Hashing Utility using F#
  • tala – Community Edition of WcfStorm.Rest
  • Shaver – Lightweight F# library for Suave.io web server using Razor engine adding some extra features like template composing, custom return codes or localization resources support.
  • StarWarsMarkov – StarWars Markov Script Generator

New Releases

That’s all for now. Have a great week.

Previous F# Weekly edition – #50Subscribe

F# Weekly #50, 2015

Welcome to F# Weekly,

A roundup of F# content from this past week:

News

Videos/Presentations

Blogs

F# vNext News 

Open source projects

New Releases

That’s all for now. Have a great week.

Previous F# Weekly edition – #49Subscribe

Application contracts with Swagger powered APIs for .NET or Why SwaggerProvider

This post is part of the F# Advent Calendar in English 2015 project.
And special thank you to Phillip Trelford for the idea of F# Advent in English year ago.

In this post I want to talk about how we design software, what we should care about and what we should not.

The story of The Contract

The initial thing is a problem. Nobody writes code without understanding what he/she is doing and what he/she expects to receive at the end. The task (problem description) may come from anywhere: it may be task from your boss or an awesome idea that pretty soon can change the world and bring you a lot of money or some tool / OSS project that will make your life easier in the future.

When you have a clear problem definition, you can start thinking about the solution. There are plenty of ways to solve any problem. You can choose any programming language, any operating system, any programming paradigm, any framework, any tool-set and so on. In order to choose one (the best in your case) solution you start applying real world constraints to reduce the number of solutions. You will probably decide to use a language and tools, which you are more familiar with or which suits better for this particular task. People do this because we all have very important real-life constraint – it is the time. Time-to-market is always important. Nobody starts writing a new operating system just because he/she can do it. We always try to minimize amount of work that should be done to speed up time-to-market.

When you actually start hacking, the thing you start with is `architecture`. Argh, I said that arch.. word. But architecture is nothing more than decomposition. If you do it right in terms of your constraints and limitations – you are almost done. After that, you should write code for small pieces and compose them to get the solution. But what defines the right decomposition? The answer is contracts!

Sounds really simple, does not it? However, it is not so far from the truth. Real-world solution architecture is always state of art, it cannot be super cool for all things, but it can fit your requirements to certain extent. All you can do mastering the architecture is to decompose your monolith idea to simple manageable components with clear responsibilities and clear contract.

The implementation of contract in programming language level is an interface (the promise of capabilities to the world). The implementation of interfaces in F#/C# is pretty good. You as a developer should only define an interface and implement it somewhere to provide a capability by contract. When you are on the other side and want to consume provided capabilities you should only reference component that defines contract and use it with almost zero overhead.

Based on the experience with interfaces, you have three ways of interaction with contract:

  1. Design (define) contract
  2. Provide (implement) contract
  3. Consume contract

But it is not so simple, when your application is larger than one executable file… What happens when you cross process and/or machine boundaries? In this case, we need a technology that allows us to setup the component that provides contract to one machine and consumes this contract on another machine with the same elegance as interfaces do this. At this moment, higher-level contracts (so called API) come to play.

There are plenty of technologies that can help you to develop some sort of API for your component. Probably first helpful thing that comes to mind is WSDL (Web Service Definition Language). When you choose WSDL as your contract language you receive plenty of tools that help you to manage your API, generate implementation from API contract, generate contract from your implementation, generate code that encapsulate all communication difficulties for consumers and so on. WSDL world is pretty mature and beautiful (I really love it), but it usually comes with SOAP and communication protocol that does not suitable for all types of cross-machine communication.

There are some real-world cases when you need more lightweight and fast communication mechanism that can be “easily” consumed from different languages and run-times. In such cases, people more often decide to provide RESTful APIs. BUT, all of you who design RESTful API for your systems and components SHOULD REMEMBER that technology that you use to design and implement contract SHOULD also provide a way to CONSUME your API. It is your responsibility to care about consumers, they should be focused on solving their own task using your API rather than writing boilerplate code to consume your API.

Swagger

One of technologies that provide such goodness for developers is Swaggernlp-logo-navbar

Swagger is a simple yet powerful representation of your RESTful API. With the largest ecosystem of API tooling on the planet, thousands of developers are supporting Swagger in almost every modern programming language and deployment environment. With a Swagger-enabled API, you get interactive documentation, client SDK generation and discoverability.

Swagger Specification is able to describe pretty wide range of RESTful APIs. Swagger comes along with Swagger Edit that allows contract first API development. APIs that have Swagger schema can easily be integrated with Swagger UI – very powerful interface that dramatically simplify studying of new API (demo). Swagger ecosystem also has tools that generate client code for wide list of languages.

In the .NET world, exists a project called Swashbuckle, which generates Swagger schema to ASP.NET WebAPI services and plugs Swagger UI in your application. I’ve already blogged about how to use Swashbuckle from F# Web Apps.

Swagger is used in ASP.NET API app in Azure App Service and may come to Nancy very soon as well.

F# Swagger Provider

swaggerAs you may already understand, Swagger ecosystem looks very promising in general and Swagger Specification perfectly matches with F# Type Providers approach. So, I am glad to present the SwaggerProvider.

In order to start you need to add reference to SwaggerProvider NuGet package and pass Swagger JSON schema to it (for this example I will use a schema from Petstore – Swagger demo app).

#r "SwaggerProvider/SwaggerProvider.dll"
open SwaggerProvider

type PetStore = SwaggerProvider<"http://petstore.swagger.io/v2/swagger.json">

So, you are generally done. Type Provider parses provided schema and generates all required data types and methods to call API. Note that SwaggerProvider is generative type provider and generates types and methods that exist in run-time, so that means that it can be used from C# code as well.

swagger_defs

swagger_pets

Even if the RESTful API that you need to consume does not gently provide Swagger schema for you, you still can use SwaggerProvider to call it. It should be easier to manually describe schema once than to write and support source code for all REST calls.

Let’s say that we want to call GitHub API to get all fsprojects repositories. For this API call schema will look like this

{
    "swagger": "2.0",
    "info": {
        "description": "This is a Sample for GitHub API.",
        "version": "1.0.0",
        "title": "Swagger GitHub"
    },
    "host": "api.github.com",
    "basePath": "/",
    "tags": [
        {
            "name": "repos",
            "description": "Repositories API"
        }
    ],
    "schemes": [ "https" ],
    "paths": {
        "orgs/{orgId}/repos": {
            "get": {
                "tags": [ "repos" ],
                "summary": "List organization repositories",
                "description": "",
                "operationId": "orgRepos",
                "consumes": [ "application/json" ],
                "produces": [ "application/json" ],
                "parameters": [
                    {
                        "name": "orgId",
                        "in": "path",
                        "description": "Organization name",
                        "required": true,
                        "type": "string"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "successful operation",
                        "schema": {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/Repo"
                            }
                        }
                    }
                }
            }
        }
    },
    "definitions": {
        "Repo": {
            "type": "object",
            "properties": {
                "id": {
                    "type": "integer",
                    "format": "int64"
                },
                "name": {
                    "type": "string"
                }
            }
        }
    }
}

If you use Visual Studio to edit Swagger schema, you will be pleasantly surprised by “Intellisense for JSON Schema in the JSON Editor

gh-vs

This JSON describes one data type Repo, that contains simplified version of GitHub Repository data type, and description of one API method /orgs/{orgId}/repos that does the job. Now you are able to use this schema to call GitHub API.

gh_def

gh_repos

But if you really want to make a call to GitHub API, you need to specify real user agent header and SwaggerProvider allows you to do this:

open SwaggerProvider

let [<Literal>] schemaFile = __SOURCE_DIRECTORY__ + "\GitHub.json"
let [<Literal>] headers = "User-Agent=Googlebot/2.1 (+http://www.google.com/bot.html)"
type GitHub = SwaggerProvider< schemaFile, headers >;

let names =
    GitHub.Repos.OrgRepos("fsprojects")
    |> Array.map (fun x -> x.Name)

gh_works

Note: SwaggerProvider does not support schemes in YAML format yet. But this feature is definitely will be implemented, because it dramatically simplifies manual schema creation.

Please share your thoughts about SwaggerProvider and do not be shy to try it and report issues if any.

Special thanks to APIs.guru project for maintenance of wide range of real-world Swagger schemes that were used to test SwaggerProvider.

Follow

Get every new post delivered to your Inbox.

Join 266 other followers