I will give a brief history of types, and will discuss some new, and not that new, type systems, such as session types (types for distributed programs), and refinement types (types with predicates). I will challenge you to think how (and why) we can stretch the notion of types and use them to prevent communication faults such as deadlocks and communication mismatches.

In particular, I will discuss two F# projects that have flirted with the idea of expressive types in F#. These are session type providers — a type provider which enables programming of safe communication protocols; and Fluid types — a toy compiler extension that infers predicates from F# programs. Finally, I will show some recent developments in OCaml, F* and other strange creatures, as to discuss how far we should (if at all) push the boundaries of the F# type system, and what are the trade-offs that we have to make.

Fable has already proved that F# is really good at transpiling. Peeble is taking the same steps to transpile F# to PHP, allowing users to integrate into environments where running .NET is not an option.

Through the example of a real world game development, you'll experience how to write F# using Fable — Elmish on the front, and the same code converted to PHP on the back. This same approach could be done to integrate easily with Go, Python, or similar languages.

The alternative to this would require us to write the full program in JavaScript and PHP, implementing 3K lines of complex game login twice in two different languages.

The end result? The game "Crazy Farmers" . You can view the code on github at https://github.com/thinkbeforecoding/crazy

With a mature .NET tool ecosystem, the time has come for the new Fable (codename Nagareyama) to fly alone, and remove the Babel dependency. We will see how this improves the Fable experience as well as the other new features coming in the new release.

The F# Software Foundation (FSSF) works tirelessly to help nurture and grow the F# community. Throughout its various programs and initiatives, one of its goals is to reduce the barrier to get started and become proficient with F#. In this 10 minutes lightning talk, Kevin Avignon will go over the multiple initiatives of the FSSF.

Mathematical Planning (MP) is the science of caring for people. It focuses on answering the question, “Given a quantifiable goal, constraints to be obeyed, and decisions to be made, what is the best plan?” Every organization is answering this question every day. Everything hinges on whether we can continually identify the best course of action. Mathematical Planning is an underutilized technology and I am on a mission to inform and empower developers to use it.

Mathematical Planning has been slowly coming into the mainstream and there are now libraries in most programming languages. Python has PuLP and Gurobi, C# has OPTANO, and F# has Flips. I will show that F#’s unique set of features make it the ideal tool for performing Mathematical Planning. These features include the functional-first nature, the algebraic types, and Units of Measure. I will show the power of Mathematical Planning and how F# addresses many of the pain points found in other languages when developing real-world Mathematical Planning models.

Join Phil as he takes us a modest journey of an open source project, from early prototypes all the way to adoption and finally hand over to new owners, and plenty of fun and games along the way.

This talk will be about the Foq project, which is pronounced Fock-U!

It's a very small project, the original source code is less than 100 lines and the final version is still in a single source file. Despite it's conciseness the project has nearly 200K downloads of the Nuget packet and has been adopted by all sorts from hedge funds to the F# compiler.

This talk goes beyond the source to look at some of the many mishaps along the way.

Software developers are often tasked with building business applications that are required to model and comply with business requirements. However, the source code for these applications often obfuscate their business requirements instead of reflecting them. This paradox can be remedied by using a strong type system and some Domain Driven Design principles. In this lightning talk, Scott Nimrod explains how business requirements can be converted into a compilable specification that application modules can interpret. The target audience for this talk is software developers.

Pulumi enables developers to leverage powerful general-purpose languages for infrastructure definitions. Now supporting .NET, allows users to use a single language for everything. Thanks to the expressiveness of the F# language features, a few computational expressions can make your infrastructure code cleaner than any other language and yet ensuring correctness by strong compile-type validation and making the development experience great using existing IntelliSense in estabilished IDEs. This talk is a journey from a great tool such as Pulumi, to a perfect, boiler-plate free, DSL for defining cross-cloud infrastructure.

F# can be used as single page application via Fable and serverside app via .NET. In this talk, Onur will discuss how F# helped him build a complicated, commercial grade, 3D bin packing application. He will address questions like how to use F# to its full extent, and in what parts you have to be careful (e.g., performance). Finally, he will demonstrate how complicated code can be run on serverside as well as on the client.

Meet one of F#'s most distinctive — if under-used — features: Units of Measure. Interactively shape the presentation while you learn how to: ensure correctness, improve intentionality, and preclude subtle bugs.

Biotech is a broad and demanding field for software development. It combines a messy domain, rapidly changing requirements and brutal timelines for software development that stress the software development life cycle. In the middle of this controlled software explosion, we have developed a platform using F# starting from a compiler that targets life itself, through to data management systems overseeing millions of liquid transfers a year. The end product of the lab engineering is a living organism (yeast based) that can manufacture the active ingredients in the Cannabis plant via fermentation. This talk will give a user-focused view into the types of problems we have to solve, and why F# and Fable have been good companions on this journey. Also why you don't want to be the only BASIC programming in a lab full of roaming monsters.

We are living in a world of ever expanding data. For the most part, Type Providers give you a way to easily communicate with data sources in a convenient, type checked way. And while there are Type Providers for virtually all the popular data sources in the market, you just might encounter a situation where you need to build a Type Provider for custom data sources.

In this talk, we discuss how Type Providers are built looking at an example building an F# Type Provider for the Edelweiss Data Platform.

Break into the world of machine learning, which is both available and easy for .NET developers. It’s imperative in today’s world to be able to make fast decisions based on real-time data.

In this session, you will learn how easy is to start using machine learning in your .NET applications via ML.NET in F# to make split-second evaluations. This session demo includes several code examples to cover different machine learning algorithms for useful cases. You will walk away from this session with knowledge on how to leverage functional approaches in combination with ML.NET, to maximize your business success.

One of the larger problems in biomedical research is reproducibility: consistent results of the same experiment is often elusive. Another problem is one of complexity — biology is inherently a complex subject and implementing it in computer code often leads to even more complications. Both of these problems can be traced, in part, to the choice of computer languages used when doing experiments.

In this session, we will look at a basic implementation of pattern matching DNA/RNA sequences using traditional code constructs and then reimplement them using F# using functional constructs. We will touch on why the F# solution addresses both the reproducibility problem as well as the code complexity problem. After this session, the attendee will gain a greater appreciation of the power of F# and how it can make complex algorithms simple.

Rule-based chatbots and dialog agents are often derided as "state-machine spaghetti code" where implementations in imperative languages like Python and C# inevitably devolve into unmanageable tangles of nested conditional logic and state mutation. The trend nowadays is to use ML models instead of rule-driven systems. But rule-based dialog systems are inherently pattern-matching systems and languages that excel at pattern-matching may be able to avoid this exponential growth in complexity.

In this talk I'll give an overview of Selma — a Web-based multimodal dialog agent for healthcare self-management written entirely in F# using WebSharper.

The main topics of this talk are:
• Using WebSharper to build client-server CUIs in F#
• Using the Wit.ai service to extract and classify utterances into dialogue acts, intents, and entities.
• Using F# active patterns to compose type-safe rules over these structures that drive the dialogue.
• How an F# conversation agent compares to MS Bot Framework or ML-driven agents.

F# is too often considered a niche language for mathematics, science, and other academic purposes. Many developers would like to use F# for business application development, but companies are reluctant to adopt the language. It's difficult to convince management that F# can bring more business value long term.

Mikhail has succeeded in convincing his organization to use F# everywhere. He has demonstrated success on both the backend and the frontend without actually having a team of F# developers.

In this session, he will share with you a case study of successful transition from common C# and JavaScript to the F# language. He will outline the technologies that were used, and the reasons why they were chosen. He will describe a journey of reimplementing an E-commerce project, including the goals that were defined, the team that was built, the obstacles that were faced, and the success that was achieved.

You will learn why Mikhail loves to say: "There is nothing impossible if you really want it!"

Don will host the first annual F# Pub Quiz. Come and test your knowledge of the history of F#, its relationship to other programming languages, its community and its tooling, and the many contributors involved over the year. Along the way Don and guests will talk through great talks from previous F# Exchange conferences, and you’ll be able to access these as extra bonus sessions available on the SkillsMatter website.