In this talk, Kit explains why F# has such a transformative effect on people who use it. Kit established that any programming language can be thought of as a belief system, helping us make sense of and manipulate the world. He explores why F# is such an effective belief system. To prove his case, he shows how he's used F# in an ambitious commercial art project, which he previewed at F# eXchange 2018 and which is coming to fruition this year. Then he shows the same principles in use in his day job at Perpetuum, where they use F# to maximise the safety and minimise the costs of the world’s rail systems.

F# is becoming more and more universal nowadays. Not only when it comes to problem domain but also to where one can run it. Desktop, Web, Mobile, IOT, Serverless - those are just examples of F# runtimes. For the purpose of this talk Tomasz will steal the (un)famous "Write once, run anywhere" slogan about Java from Sun Microsystems and see how you can apply it to F#.

This is a live coding session based on a classic 1982 paper by Peter Henderson. The paper shows the decomposition and reconstruction of Escher's woodcutting "Square Limit", a beautiful recursive tessellation of interleaving fish, using functional programming. Einar will define a set of functions that operate on pictures - transforming them and composing them into more complex pictures. With these functions implemented, you will follow in Henderson's footsteps to create a replica of Escher's Square Limit as an SVG - in the browser, courtesy of Fable.

Programming has evolved from listing mechanical instructions for a computer to writing gigantic works in evolved languages that sometimes remind their natural counterparts. However, more often than not we forget this connection and look at other fields like Mathematics in the search for models to improve the art of Programming. Alfonso proposes we turn our eyes on to natural languages again to take inspiration from techniques used by humans to centuries ago to better articulate our programs, improve the semantics in our code, and communicate much more efficiently in a team.

In a functional world, you can often dispense with explicit interface definitions, because a function's inputs and outputs are an implicit interface. Combining this idea with F#'s automatic generalization gives you a powerful tool for easily bolting on useful features, anywhere in your program. Caching, logging, telemetry, resiliency, backend migrations, user experimentation, feature flags/slow rollout, stress testing, and validation are examples of areas where this technique really shines, and keeps your core business logic cleanly separated and testable. In this talk, Erik will sketch out a number of these ideas with F#, providing inspiration for developers to take a fresh look at how they can develop, improve, and extend their applications.

So you heard so much stuff about Event-Sourcing. Now you want to know what all the hype is about but you don’t know where to start. Everything sounds quite complicated and there are many new concepts to learn. Do you need to use one of the available frameworks? Do you really need solutions for problems that you might never encounter? Wouldn’t it be great if you could experience those problems first-hand and to be able to tailor solutions to your application’s specific needs?

In this session, Roman wants to take you on a journey that will eventually enable you to build your own Event-Sourced system. Together you will define the requirements and he is going to give you ideas and approaches to fulfil those requirements. Eventually, you will see, why a language like F# is such a perfect fit for this kind of architecture.

In recent years there has been a shift in the way websites and mobile apps are being built - moving to architectures with immutable models and virtual UIs based on the MVU (model-view-update) pattern. This has led to great new frameworks like ELM and React for web, and ReactNative for mobile.

Now there is a new MVU framework for building mobile apps - Fabulous. It's a community-driven open source framework, combining the simplicity of an MVU framework, with 100% native API access for both iOS and Android, all built with F#.

In this session, Jim will start with an overview of MVU, discussing how it works and why it is such a great architecture. He will then move on to building a first Fabulous app that runs on iOS and Android. Next up more features will be added to the app whilst the app is running on a device, showing the hot reload capabilities of Fabulous for both UI and app logic. Finally he will look at the underlying architecture, see how to use all of the iOS and Android APIs, see how to easily use native components such as cocoa pods or jars, and look at the massive range of libraries that this framework has available to it to do all manner of UI and application logic things. Jim will even explore how to use it on macOS and Windows, including being able to build iOS apps on Windows (with the help of a networked Mac, Apple licensing rules and whatnot).

When looking at naming for this framework, someone suggested Fabulous. By the end of this session, you will see why that name stuck.

In the 1840s Charles Babbage proposed, but never built, an entirely mechanical, Turing-complete computer that he called the Analytical Engine. The designs were sufficiently complete that Ada, Countess of Lovelace (among others), was able to design 'programs' for it; this also means that we can model its behaviour with a reasonable degree of accuracy. This talk describes some of the architectural features of the machine. Together with John, you will also model its behaviour in F# to the point where you can run some simple programs on the virtual machine.

Having worked in mobile app development for years Kunjan can say one thing for sure: creating a mobile application is hard. Creating a cross-platform mobile application is even harder. Which is why he was interested when Fabulous came out.

Fabulous is a new cross-platform mobile library which mixes Xamarin-Forms and Elm Architecture. The Elm language and architecture were not new to him. He has been using it for a year and it had left a positive impression on him. So, it was only natural that Fabulous attracted his attention. The first time he tried it after it got launched, he wasn’t impressed by its performance, but recently he gave it another try for a production application and he was amazed. Kunjan was able to create a complete app.

In this talk, Kunjan will tell you why he chooses Fabulous instead of other Cross Platform mobile development options for his app. He will walk you through all the mobile-specific changes he made to get Fabulous working in a performant way for iOS and Android and explain to you how you can use in combination with third-party plugins.

The MVC pattern has been one of the most important architectural patterns for server-side web development - it has been implemented and popularized by frameworks like Ruby On Rail or ASP.NET MVC. However, this pattern was traditionally coupled with object-oriented programming. In the talk, Krzysztof will show how to reinvent MVC pattern, and structure your web application in a functional language - F#. The talk will cover some brief introduction to F# - modern functional programming language running on .Net platform, show how to model MVC layers using functional composition, and at the end show some examples of applying MVC pattern with Saturn - opinionated, web development framework for F# which implements the server-side, functional MVC pattern

Dungeons & Dragons, or D&D, is the grand-daddy of all role-playing games. While playing D&D is great fun, the rules are a bit daunting for the beginner. The basic rulebook, the PHB, clocks in at a solid 300 pages, and can be extended with multiple additional rule sets. This should come as no surprise to software engineers: this is, after all, documentation for a system that models a complex domain, and has been in use for over 40 years now, going through numerous redesigns over time. As such, D&D rules make for a great exercise in domain modelling. In this talk, I will take you along my journey attempting to tame that monster. We will use no magic, but a weapon imbued with great power, F#; practical tips and tricks for the Adventurer on the functional road will be shared. So... roll 20 for initiative, and join us for an epic adventure in domain modelling with F#!

At Petersburg Consultants in Doorwerth (the Netherlands), they develop in-house software for structural mechanical and electrotechnical modelling of overhead lines, electricity power stations, and underground cables. With the energy transition gaining momentum, data and its transformation are key in Petersburg's ambition to show leadership in the energy transition. Dennis wants to show that F# surely is our path to relaxation. During his talk, Dennis will share how they have shaped the above by using the information-rich programming that F# offers, e.g. type providers, and the algebraic type system. Adding to that, appealing visualizations in FsLab's XPlot and reporting in FsJournal. Time permitting, he can even go into how they use FsCheck to make sure their models are robust and make physical sense.

Rumyana will give a (very) brief history of types and will discuss some (new and not that new) type systems, such as session types (types for distributed programs), refinement types (types with predicates). In this talk, she will challenge you to think how (and why) you can stretch the notion of types and make them accessible to the F# community. She will show you how to hack the F# compiler and use some typed goodies. In particular, she will talk about, Fluid Types, a project which aims to infer predicates from F# programs. She will discuss how far you should push the boundaries of the F# type system (if at all), and what are the trade-offs that we have to make.

Roman has been happily working as fulltime F# developer for nearly three years now. How did that happen that desperate C# developer turned into F# lover turning his passion into money and fun? What can you do in your company to convince your boss to give F# a shot? And how to sell F# to customers? In this lightning talk, Roman will share some tips from his experience you might find useful.

Modern cloud applications consist of many moving parts, so they are hard to manage without employing Infrastructure-as-Code approach. Traditionally, tools like CloudFormation, ARM templates and Terraform employ text-based templates, which tend to be tedious, repetitive and difficult to reuse. What if instead of configuration files you could just use F#? See how to bring types, components, and much more to your cloud infrastructure definition.

In this lightning talk, Stuart will share with you what Giraffe is, how it works, what a Giraffe application looks like, and a look at some of the features.

A programming language cannot be widespread without supporting widely used data formats, like JSON. One of the main problems of F# is not the language itself but lack of libraries choice and specifically lack of libraries designed with F# language in mind. This talk will cover how to (de)serialize JSON in F#.

Vladimir will share how serialization/deserialization should look like to call it F#-friendly. Then he will explore some of the existing libraries: JSON type providers, adoption of Newtonsoft, also more F#-targeted libraries: Chiron, FSharpLu.Json and created by author FSharp.Json: https://github.com/vsapronov/FSharp.Json

f(x) = y, but y = 5. What's the probability that x =1? Probabilistic programming is the idea of describing probabilistic models as programs, to then automatically infer how our beliefs about model parameters change given observed data. In recent years, probabilistic programming languages (such as Stan) have demonstrated the power of this approach by becoming the underlying tool behind numerous projects in social science, biology, genetics, astrophysics, and engineering. But why haven't such languages been more widely adopted yet? In this talk, Maria will talk about the nuts and bolts of probabilistic programming languages, addressing the challenges behind making these languages general-purpose, automatic, and efficient. In addition, she will discuss how ideas from programming-language research can be adopted in probabilistic systems, and how F# has helped her in the endeavour of bridging the gap between statistical modelling and probabilistic inference.

When you hear terms like data science and artificial intelligence, you probably imagine fitting fancy mathematical models to data. Well, this is only the tip of the metaphorical iceberg of data science. In practice, it is also the part that ultimately amounts to calling a one-line function from some library. The part of the iceberg hiding underwater is all the work that's required to get to the actual model fitting stage. This is the area where F# really shined for Evelina. Since joining the UK's national centre for artificial intelligence, she has used F# successfully in several projects. In this talk, Evelina will show you some of the practical cases where F# has been instrumental in solving real-world problems with real-world data.

Serverless architecture is the future of the cloud. Initially, the serverless tech focused on running small isolated tasks in response to cloud events. The next evolutionary step is to compose complex applications out of those small components. Azure Durable Functions provides powerful abstractions for workflow composition on top of standard Functions. Join Mikhail, the author of DurableFunctions.FSharp library, to see how F# is the most powerful language to orchestrate stateful, reliable, long-running serverless applications.

In this presentation, Rune will start out by outlining a series of C# problems that he encountered working on a big music streaming service with 100.000+ simultaneous users. The presentation details the actual journey of a team of extremely quality conscious developers and how they ended up switching from C# to F#.

The presentation stands out for two reasons:

• It is a complete story, that plays out over almost three years on a real, customer facing application.
• Our team didn’t have F# as an end goal, so the presentation is focused on solving some common issues in C# - that in turn led us to F#.

Working with cloud-based data sources often means giving up some of the benefits we're used to when working with conventional relational data stores such as schemas and local access. This talk will focus on how you can make use of F#’s type system in tandem with distant data sources in order to provide a stable foundation for developing on top of standard Azure services, through the use of type providers. You'll look at the Azure Storage Type Provider in particular, and will illustrate how to use it to simplify many day-to-day development tasks around working with blobs, tables and queues. Through slides and live coding demos, you'll see how type providers can simplify many day-to-day tasks as well provide extra safety through inferred types from remote data stores. Finally, you’ll also discuss some of the challenges both with working with remote schemas, working with chargeable services and how to work with continuous integration scenarios.

• HHS modernization & DHS high-level project overviews (asylum generator & MPSM)
• High level open source wish list
  • claims processing
  • data specifications
  • paper is the problem
  • forms modernization

  - single signon

• agile contracts
• server-less products & contrainerization
• devops & design in government
• how to get involved in civic tech

This workshop will show you how to use F# for solving common Machine Learning problems.

Sudipta will take several examples from his F# for Machine learning book (F# for Machine Learning Essentials, published by Packt)

You will be learning how to use F# and .NET machine learning frameworks like Accord.NET to solve problems in supervised learning, sentiment analysis and recommender systems.

By the end of the workshop, you will feel confident about solving a machine learning problem with F# and other related .NET frameworks.

Pre-requisites for the workshop:

• Jupyter Notebook
• Visual Studio Express Edition with F#
• https://github.com/fsprojects/IfSharp

The SAFE Stack is a set of tools and libraries which allows you to quickly and easily build end to end F# web applications. In this workshop, you'll build a web application which uses Saturn for its backend API, Fable for the front end and Elmish to build a functional UI. By the end of the workshop, you'll have a working web application ready to be deployed to the cloud.

Pre-requisities for the workshop are listed here.

In this talk, Bartosz will briefly cover how GraphQL standard can change your perspective on building web services. Next, he'll share about its tradeoffs over standard REST applications, and how they decided to address them in the F# implementation of GraphQL server (known as FSharp.Data.GraphQL) as well as what future improvements they could achieve.

Bootstrap web apps quickly using advanced dotnet template. Use the power of F# to build rich client without ever touching bare JS. Extract common code to reuse between front and back end in the same language. Deploy to a selected cloud provider using built-in supporting scripts. Sounds exciting? You can do all of that with SAFE! During this talk you'll explore the possibilities and tooling around SAFE and see that the future of the stack looks really promising.

Later this year, F# 5.0 is intended to be delivered. This is the first major language bump in quite some time, and with that bump comes a certain understanding that bears explanation! In this talk, you'll learn about the various features that will make it into F# 5.0, some of the behaviour changes the team behind it have in mind, and what you might expect of the future of the F# language in a post-5.0 world.