diff --git a/.github/workflows/markdown-lint.yml b/.github/workflows/markdown-lint.yml new file mode 100644 index 00000000..0cc9b1df --- /dev/null +++ b/.github/workflows/markdown-lint.yml @@ -0,0 +1,21 @@ +name: Markdown Lint + +on: [push, pull_request] + +jobs: + lint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + - uses: tj-actions/changed-files@v45 + id: changed-files + with: + files: '**/*.md' + separator: "," + - uses: DavidAnson/markdownlint-cli2-action@v19 + if: steps.changed-files.outputs.any_changed == 'true' + with: + globs: ${{ steps.changed-files.outputs.all_changed_files }} + separator: "," diff --git a/.markdownlint-cli2.jsonc b/.markdownlint-cli2.jsonc new file mode 100644 index 00000000..3b308f8a --- /dev/null +++ b/.markdownlint-cli2.jsonc @@ -0,0 +1,22 @@ +{ + // Enable all rules by default + "default": true, + + // Line length: increase default from 80 + "MD013": { + "line_length": 100, + "code_blocks": false, + "tables": false + }, + + // Allow duplicate headers in different nested sections + "MD024": { + "allow_different_nesting": true + }, + + // Allow inline HTML + "MD033": false, + + // First line in a file doesn't need to be a top-level header + "MD041": false, +} diff --git a/README.md b/README.md index 3b00c1ab..3ecf7ffd 100644 --- a/README.md +++ b/README.md @@ -53,7 +53,6 @@ Example: Not ideal, but oh well. - ## Developing locally The easiest way to get started developing this repository on your own machine is by using the supplied dev container. diff --git a/_books/F#_high_performance_2017.md b/_books/F#_high_performance_2017.md index 632666fa..cb74886b 100644 --- a/_books/F#_high_performance_2017.md +++ b/_books/F#_high_performance_2017.md @@ -14,4 +14,4 @@ In this book you will: - Implement best practices to optimize performance - Use the available tooling to help measure performance - Combine the best practice of asynchronous and synchronous -- Optimize further using various F# language constructs \ No newline at end of file +- Optimize further using various F# language constructs diff --git a/_books/beginning_f#_4_2016.md b/_books/beginning_f#_4_2016.md index 14de3113..28a44bdd 100644 --- a/_books/beginning_f#_4_2016.md +++ b/_books/beginning_f#_4_2016.md @@ -8,4 +8,4 @@ bookurl: https://link.springer.com/book/10.1007/978-1-4842-1374-2 This book is a great foundation for exploring functional-first programming and its role in the future of application development. The best-selling introduction to F#, now thoroughly updated to version 4.0, will help you learn the language and explore -its new features. \ No newline at end of file +its new features. diff --git a/_books/building_f#_applications_video_2017.md b/_books/building_f#_applications_video_2017.md index ea0a3c2e..d518715b 100644 --- a/_books/building_f#_applications_video_2017.md +++ b/_books/building_f#_applications_video_2017.md @@ -11,4 +11,4 @@ Learn how to use F#'s functional features to rapidly turn requirements into soft - Use F#-friendly tools for test automation, builds, and dependency management - Model your application's problem domain using F#'s immutable data types and collections - Build simple-to-complex application behavior with F# functions -- Interoperate between your F# applications and other .NET languages \ No newline at end of file +- Interoperate between your F# applications and other .NET languages diff --git a/_books/domain_modeling_made_functional_2018.md b/_books/domain_modeling_made_functional_2018.md index 6b3e5086..183d72e5 100644 --- a/_books/domain_modeling_made_functional_2018.md +++ b/_books/domain_modeling_made_functional_2018.md @@ -11,4 +11,4 @@ Domain-driven design is a well-established approach to designing software that e Model a complex domain accurately using the F# type system, creating compilable code that is also readable documentation—ensuring that the code and design never get out of sync. Encode business rules in the design so that you have “compile-time unit tests,” and eliminate many potential bugs by making illegal states unrepresentable. Assemble a series of small, testable functions into a complete use case, and compose these individual scenarios into a large-scale design. Discover why the combination of functional programming and DDD leads naturally to service-oriented and hexagonal architectures. Finally, create a functional domain model that works with traditional databases, NoSQL, and event stores, and safely expose your domain via a website or API. -Solve real problems by focusing on real-world requirements for your software. \ No newline at end of file +Solve real problems by focusing on real-world requirements for your software. diff --git a/_books/essential_f#.md b/_books/essential_f#.md index ab986b31..018874e5 100644 --- a/_books/essential_f#.md +++ b/_books/essential_f#.md @@ -5,8 +5,8 @@ year: 2023 image: /learn/files/book_covers/essential_fsharp.jpeg bookurl: https://leanpub.com/essential-fsharp --- -This is a practical book aimed at efficiently getting you up to speed with the essentials functional-first programming in F#. +This is a practical book aimed at efficiently getting you up to speed with the essentials functional-first programming in F#. -Everywhere you look, programming languages are gaining functional features. The problem is that it's not the individual features that make functional programmers happy, it's the way that your approach to writing software and the features work together to help you write simple code to solve interesting problems. This book will help you to discover why F# is such a popular language with those who have spent time learning its secrets. +Everywhere you look, programming languages are gaining functional features. The problem is that it's not the individual features that make functional programmers happy, it's the way that your approach to writing software and the features work together to help you write simple code to solve interesting problems. This book will help you to discover why F# is such a popular language with those who have spent time learning its secrets. -This book started life as a series of blog posts on my Company's website (https://www.softwarepark.cc/blog). The sum of the content is what a developer needs to know to be able to work on one of our F# Line of Business codebases. I have improved and extended the content, upgraded the code to F# 5 and ensured that the code will run in VS Code. \ No newline at end of file +This book started life as a series of blog posts on my Company's website (). The sum of the content is what a developer needs to know to be able to work on one of our F# Line of Business codebases. I have improved and extended the content, upgraded the code to F# 5 and ensured that the code will run in VS Code. diff --git a/_books/export_f#_4_2015.md b/_books/export_f#_4_2015.md index e08007d2..1a3cd085 100644 --- a/_books/export_f#_4_2015.md +++ b/_books/export_f#_4_2015.md @@ -7,8 +7,8 @@ bookurl: https://link.springer.com/book/10.1007/978-1-4842-0740-6 --- Expert F# 4.0 is about practical programming in a beautiful language that puts the power and elegance of data-rich functional programming into the hands of professional developers. In combination with .NET, F# achieves unrivaled levels of programmer productivity and program clarity. - - A comprehensive guide to F# by the inventor of F# - - A treasury of F# techniques for practical problem-solving - - An in-depth case book of how F# applications and of F# 4.0 concepts, syntax, and features +- A comprehensive guide to F# by the inventor of F# +- A treasury of F# techniques for practical problem-solving +- An in-depth case book of how F# applications and of F# 4.0 concepts, syntax, and features -The world's experts in F# show you how to program in F# the way they do! \ No newline at end of file +The world's experts in F# show you how to program in F# the way they do! diff --git a/_books/f#_4_design_patterns_2016 .md b/_books/f#_4_design_patterns_2016 .md index 8266ce51..3b1b7967 100644 --- a/_books/f#_4_design_patterns_2016 .md +++ b/_books/f#_4_design_patterns_2016 .md @@ -16,4 +16,4 @@ In this book you will: - Make use of native F# algebraic data types in place of custom-built classes - Recognize and measure the difference in resource consumption between sequences and materialized data collections - Navigate and use F# Core libraries with ease by seeing patterns behind specific library functions -- Master writing generic polymorphic code \ No newline at end of file +- Master writing generic polymorphic code diff --git a/_books/f#_applied_2016.md b/_books/f#_applied_2016.md index b608dcf8..db3b4b1b 100644 --- a/_books/f#_applied_2016.md +++ b/_books/f#_applied_2016.md @@ -12,4 +12,4 @@ In this book you will read: - An in-depth understanding of Web development in F# using Suave - How to develop applications using EventSourcing, CQRS, and DDD in F# - How to set up continuous integration and continuous deployment using FAKE and Docker -- How to leverage libraries like Rx, FSharp.Data and Paket \ No newline at end of file +- How to leverage libraries like Rx, FSharp.Data and Paket diff --git a/_books/f#_deep_dives_2014.md b/_books/f#_deep_dives_2014.md index b5d2dab7..26a8bec9 100644 --- a/_books/f#_deep_dives_2014.md +++ b/_books/f#_deep_dives_2014.md @@ -5,4 +5,4 @@ year: 2014 image: /learn/files/book_covers/fsharp_deep_dives.jpg bookurl: https://www.manning.com/books/f-sharp-deep-dives --- -_F# Deep Dives_ presents a collection of real-world F# techniques, each written by expert practitioners. Each chapter presents a new use case where you'll read how the author used F# to solve a complex problem more effectively than would have been possible using a traditional approach. You'll not only see how a specific solution works in a specific domain, you'll also learn how F# developers approach problems, what concepts they use to solve them, and how they integrate F# into existing systems and environments. \ No newline at end of file +_F# Deep Dives_ presents a collection of real-world F# techniques, each written by expert practitioners. Each chapter presents a new use case where you'll read how the author used F# to solve a complex problem more effectively than would have been possible using a traditional approach. You'll not only see how a specific solution works in a specific domain, you'll also learn how F# developers approach problems, what concepts they use to solve them, and how they integrate F# into existing systems and environments. diff --git a/_books/f#_for_machine_learning_essentials_2016.md b/_books/f#_for_machine_learning_essentials_2016.md index 711d1162..d3220f45 100644 --- a/_books/f#_for_machine_learning_essentials_2016.md +++ b/_books/f#_for_machine_learning_essentials_2016.md @@ -5,11 +5,12 @@ year: 2016 image: /learn/files/book_covers/fsharp_for_machine_learning_essentials.jpg bookurl: https://www.packtpub.com/en-us/product/f-for-machine-learning-essentials-9781783989348 --- -The F# functional programming language enables developers to write simple code to solve complex problems. With F#, developers create consistent and predictable programs that are easier to test and reuse, simpler to parallelize, and are less prone to bugs. If you want to learn how to use F# to build machine learning systems, then this is the book you want. Starting with an introduction to the several categories on machine learning, you will quickly learn to implement time-tested, supervised learning algorithms. You will gradually move on to solving problems on predicting housing pricing using Regression Analysis. You will then learn to use Accord.NET to implement SVM techniques and clustering. +The F# functional programming language enables developers to write simple code to solve complex problems. With F#, developers create consistent and predictable programs that are easier to test and reuse, simpler to parallelize, and are less prone to bugs. If you want to learn how to use F# to build machine learning systems, then this is the book you want. Starting with an introduction to the several categories on machine learning, you will quickly learn to implement time-tested, supervised learning algorithms. You will gradually move on to solving problems on predicting housing pricing using Regression Analysis. You will then learn to use Accord.NET to implement SVM techniques and clustering. You will also learn to build a recommender system for your e-commerce site from scratch. Finally, you will dive into advanced topics such as implementing neural network algorithms while performing sentiment analysis on your data. #### Who is this book for? + If you are a C# or an F# developer who now wants to explore the area of machine learning, then this book is for you. Familiarity with theoretical concepts and notation of mathematics and statistics would be an added advantage. #### What you will learn @@ -22,6 +23,7 @@ Use a recommender system for your own problem domain Identify tourist spots across the globe using inputs from the user with decision tree algorithms. #### Key benefits + Design algorithms in F# to tackle complex computing problems Be a proficient F# data scientist using this simple-to-follow guide -Solve real-world, data-related problems with robust statistical models, built for a range of datasets \ No newline at end of file +Solve real-world, data-related problems with robust statistical models, built for a range of datasets diff --git a/_books/f#_for_quantitative_finance_2013.md b/_books/f#_for_quantitative_finance_2013.md index fd9d7ec1..6f0aa31f 100644 --- a/_books/f#_for_quantitative_finance_2013.md +++ b/_books/f#_for_quantitative_finance_2013.md @@ -21,4 +21,4 @@ In this book you will: - Model orders and market data together with basic pre-trade risk - Structure and write object-oriented code - Develop larger programs using F# -- Explore automated trading systems and quantitative trading models \ No newline at end of file +- Explore automated trading systems and quantitative trading models diff --git a/_books/f#_for_scientists_2008.md b/_books/f#_for_scientists_2008.md index 72d48c9f..2c4e412b 100644 --- a/_books/f#_for_scientists_2008.md +++ b/_books/f#_for_scientists_2008.md @@ -10,4 +10,4 @@ programming language. The book assumes no prior experience and guides the reader the basics of computer programming to the implementation of state-of-the-art algorithms. Written in a clear and concise style, F# for Scientists is well suited for researchers, scientists. It also serves as an -ideal supplemental text for advanced undergraduate and graduate students with a background in science or engineering. \ No newline at end of file +ideal supplemental text for advanced undergraduate and graduate students with a background in science or engineering. diff --git a/_books/f#_ile_fonksiyonel_programlama_2021.md b/_books/f#_ile_fonksiyonel_programlama_2021.md index 83493396..6a938ac7 100644 --- a/_books/f#_ile_fonksiyonel_programlama_2021.md +++ b/_books/f#_ile_fonksiyonel_programlama_2021.md @@ -8,4 +8,4 @@ bookurl: https://www.dikeyeksen.com/products/f-ile-fonksiyonel-programlama?varia This book is the first and the only F# book in Turkish. The book covers F# and general functional programming principles. F#, aktif ve bağımsız geliştirici topluluğu tarafından yön verilen, özellikle bulut teknolojileri, veri analizi ve bilimsel çalışmalarda kullanımı her geçen gün artan sade ve şık bir programlama dilidir. -F# ile Microsoft'un .NET platformu üzerinde Windows, Linux ve OSX işletim sistemlerinde çalışabilen her çapta ve özllikte uygulamalar geliştirebilirsiniz. Hatta sistem yönetimi scriptlerinizi bile F# ile oluşturabilirsiniz. F# ile Fonksiyonel Programlama kitabında F#'ın sunduğu tüm bu imkanlar ile sizi tanıştırmayı ve bol kod örnekleri ile F#'ı özümsemenizi hedefliyoruz. \ No newline at end of file +F# ile Microsoft'un .NET platformu üzerinde Windows, Linux ve OSX işletim sistemlerinde çalışabilen her çapta ve özllikte uygulamalar geliştirebilirsiniz. Hatta sistem yönetimi scriptlerinizi bile F# ile oluşturabilirsiniz. F# ile Fonksiyonel Programlama kitabında F#'ın sunduğu tüm bu imkanlar ile sizi tanıştırmayı ve bol kod örnekleri ile F#'ı özümsemenizi hedefliyoruz. diff --git a/_books/f#_in_action_2024.md b/_books/f#_in_action_2024.md index 97b6920b..cd3ea7f7 100644 --- a/_books/f#_in_action_2024.md +++ b/_books/f#_in_action_2024.md @@ -20,4 +20,4 @@ In F# in Action you will learn how to: - Effectively model data using a variety of techniques - Use scripts to rapidly explore domains -_F# in Action_ is based on author and Microsoft F# MVP Isaac Abraham’s years of experience working with developers as an F# consultant. It upgrades .NET development skills with the core principles of functional programming, and you’ll soon see how F#’s functional-first approach makes it easy to learn this powerful paradigm. \ No newline at end of file +_F# in Action_ is based on author and Microsoft F# MVP Isaac Abraham’s years of experience working with developers as an F# consultant. It upgrades .NET development skills with the core principles of functional programming, and you’ll soon see how F#’s functional-first approach makes it easy to learn this powerful paradigm. diff --git a/_books/functional_programming_using_f#_2013.md b/_books/functional_programming_using_f#_2013.md index 86e13f3c..9c01695b 100644 --- a/_books/functional_programming_using_f#_2013.md +++ b/_books/functional_programming_using_f#_2013.md @@ -13,4 +13,4 @@ library, the imperative features of F# and topics such as text processing, seque computation expressions and asynchronous computation. With a broad spectrum of examples and exercises, the book is perfect for courses in functional programming and for self-study. Enhancing its use as a text is an accompanying website with downloadable programs, lecture -slides, a mini-projects and links to further F# sources. \ No newline at end of file +slides, a mini-projects and links to further F# sources. diff --git a/_books/learning_functional_programming_with_f#_2017.md b/_books/learning_functional_programming_with_f#_2017.md index 2b9c0046..f6393067 100644 --- a/_books/learning_functional_programming_with_f#_2017.md +++ b/_books/learning_functional_programming_with_f#_2017.md @@ -10,4 +10,4 @@ Develop web applications that includes server-side as well as the client-side pr - Learn F# with this learner-friendly approach in this course - This single course covers all the basics so you can start building powerful applications -- Get familiar with all the top modules and components included in this course \ No newline at end of file +- Get familiar with all the top modules and components included in this course diff --git a/_books/machine_learning_projects_for_dotnet_developers_2015.md b/_books/machine_learning_projects_for_dotnet_developers_2015.md index 578d9dcb..29e08368 100644 --- a/_books/machine_learning_projects_for_dotnet_developers_2015.md +++ b/_books/machine_learning_projects_for_dotnet_developers_2015.md @@ -5,4 +5,4 @@ year: 2015 image: /learn/files/book_covers/machine_learning_projects_for_dotnet_developers.jpg bookurl: https://www.amazon.com/Machine-Learning-Projects-NET-Developers/dp/1430267674/?tag=mathias-brandewinder-20 --- -Machine Learning Projects for .NET Developers shows you how to build smarter .NET applications that learn from data, using simple algorithms and techniques that can be applied to a wide range of real-world problems. \ No newline at end of file +Machine Learning Projects for .NET Developers shows you how to build smarter .NET applications that learn from data, using simple algorithms and techniques that can be applied to a wide range of real-world problems. diff --git a/_books/mastering_f#_2016.md b/_books/mastering_f#_2016.md index 990633d5..ba99df80 100644 --- a/_books/mastering_f#_2016.md +++ b/_books/mastering_f#_2016.md @@ -15,4 +15,4 @@ In this book you will: - Create and use type providers that help perform data analysis from within Visual Studio - Develop applications with pure F# code in WPF or ASP.NET MVC - Find out how to perform distributed programming with ServiceBus or ZeroMQ -- Visualize data with charts, and work with Excel and R language Type providers \ No newline at end of file +- Visualize data with charts, and work with Excel and R language Type providers diff --git a/_books/multi-paradign_programming_using_f#_and_dotnet.md b/_books/multi-paradign_programming_using_f#_and_dotnet.md index d57c3459..1d65273f 100644 --- a/_books/multi-paradign_programming_using_f#_and_dotnet.md +++ b/_books/multi-paradign_programming_using_f#_and_dotnet.md @@ -18,4 +18,4 @@ In this book you will read: - Object Oriented Programming (Objects, Classes, Inheritance, Abstraction, Polymorphism, ...) - Error Handling (Exceptions, Exception Types, Throwing and Catching Exceptions, ...) - Databases (Sql Server, Query Expressions, Type Providers, ...) -- User Interfaces (Windows Forms, WPF, GTK#) \ No newline at end of file +- User Interfaces (Windows Forms, WPF, GTK#) diff --git a/_books/programming_language_concepts_2017.md b/_books/programming_language_concepts_2017.md index 14b0266d..06baac2d 100644 --- a/_books/programming_language_concepts_2017.md +++ b/_books/programming_language_concepts_2017.md @@ -5,4 +5,4 @@ year: 2017 image: /learn/files/book_covers/programming_language_concepts.webp bookurl: https://link.springer.com/book/10.1007/978-3-319-60789-4 --- -The book Programming Language Concepts (PLC) provides an introduction to programming language concepts and implementation technology, such as interpretation, compilation, type checking and type inference, abstract machines, and garbage collection. F# is used as a meta language throughout the book expressing all concepts and examples of programming language design in a modern strongly-typed language of the ML-family, enabling the reader to experiment with the ideas right away. \ No newline at end of file +The book Programming Language Concepts (PLC) provides an introduction to programming language concepts and implementation technology, such as interpretation, compilation, type checking and type inference, abstract machines, and garbage collection. F# is used as a meta language throughout the book expressing all concepts and examples of programming language design in a modern strongly-typed language of the ML-family, enabling the reader to experiment with the ideas right away. diff --git a/_books/real_world_functional_programming_2010.md b/_books/real_world_functional_programming_2010.md index c491cf95..63e87f07 100644 --- a/_books/real_world_functional_programming_2010.md +++ b/_books/real_world_functional_programming_2010.md @@ -10,4 +10,4 @@ functional programming model through the F# and C# languages. The clearly presented ideas and examples teach readers how functional programming differs from other approaches. It explains how ideas look in F#-a functional language-as well as how they can be successfully used to solve -programming problems in C#. \ No newline at end of file +programming problems in C#. diff --git a/_books/stylish_f#_6_2022.md b/_books/stylish_f#_6_2022.md index 68fb3397..cb3a9426 100644 --- a/_books/stylish_f#_6_2022.md +++ b/_books/stylish_f#_6_2022.md @@ -18,4 +18,4 @@ _Stylish F# 6_ covers every design decision that a developer makes in constructi - Identify and implement opportunities to use function injection to improve program design - Appreciate the methods available to handle unknown data values - Understand asynchronous and parallel programming in F#, and how it differs from C# asynchronous programming -- Exploit records and anonymous records as low-overhead, easily comparable containers for structured data \ No newline at end of file +- Exploit records and anonymous records as low-overhead, easily comparable containers for structured data diff --git a/_books/the_book_of_f#_2014.md b/_books/the_book_of_f#_2014.md index 35fc499f..0a1edd88 100644 --- a/_books/the_book_of_f#_2014.md +++ b/_books/the_book_of_f#_2014.md @@ -5,4 +5,4 @@ year: 2014 image: /learn/files/book_covers/book_of_fsharp.png bookurl: https://nostarch.com/fsharp --- -The Book of F# aims to introduce intermediate and experienced developers to functional-first programming with F#. Throughout the book, you'll learn how this robust language can help you focus on creating correct solutions by introducing a variety of important concepts including currying, partial application, pattern matching, units of measure, asynchronous workflows, query expressions, type providers, and computation expressions. Furthermore, you'll discover how F#'s rich object-oriented capabilities allow it to naturally fit into existing applications. \ No newline at end of file +The Book of F# aims to introduce intermediate and experienced developers to functional-first programming with F#. Throughout the book, you'll learn how this robust language can help you focus on creating correct solutions by introducing a variety of important concepts including currying, partial application, pattern matching, units of measure, asynchronous workflows, query expressions, type providers, and computation expressions. Furthermore, you'll discover how F#'s rich object-oriented capabilities allow it to naturally fit into existing applications. diff --git a/_layouts/default.html b/_layouts/default.html index fbdfe9dd..5969e495 100644 --- a/_layouts/default.html +++ b/_layouts/default.html @@ -1,14 +1,14 @@ ---- -layout: main ---- -
-
-
-

{{ page.headline }}

-
-
- {{ content }} -
-
-
- +--- +layout: main +--- +
+
+
+

{{ page.headline }}

+
+
+ {{ content }} +
+
+
+ diff --git a/_layouts/main.html b/_layouts/main.html index c7204f2c..5fbf5da7 100644 --- a/_layouts/main.html +++ b/_layouts/main.html @@ -1,91 +1,91 @@ - - - - - - - - - {{ page.title }} - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - {% include navbar.html %} - -
-
- {{ content }} -
- -
-
-
- {% comment %} - may show a momentary flash of the year that the site was last built, - before being replaced with the actual current year by alpine - {% endcomment %} -

Copyright © 2012-{{ 'now' | date: "%Y" }} F# contributors. -

Maintained by the F# community on GitHub.

-
-
-
- - - - - - + + + + + + + + + {{ page.title }} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + {% include navbar.html %} + +
+
+ {{ content }} +
+ +
+
+
+ {% comment %} + may show a momentary flash of the year that the site was last built, + before being replaced with the actual current year by alpine + {% endcomment %} +

Copyright © 2012-{{ 'now' | date: "%Y" }} F# contributors. +

Maintained by the F# community on GitHub.

+
+
+
+ + + + + + diff --git a/_snippets/async_expressions.md b/_snippets/async_expressions.md index 4f030a7d..c14854d6 100644 --- a/_snippets/async_expressions.md +++ b/_snippets/async_expressions.md @@ -31,4 +31,4 @@ F# async expressions provide a powerful way to handle asynchronous programming, - **Integration with existing libraries** makes it easy to use async expressions with other F# features - **Error handling** is simplified with the use of discriminated unions and pattern matching - **Seamless integration** with F#'s type system ensures type safety and reduces runtime errors -- **Support for cancellation** and timeouts allows you to manage long-running operations effectively \ No newline at end of file +- **Support for cancellation** and timeouts allows you to manage long-running operations effectively diff --git a/_snippets/computation_expressions.md b/_snippets/computation_expressions.md index 6988d6a2..d5aba953 100644 --- a/_snippets/computation_expressions.md +++ b/_snippets/computation_expressions.md @@ -38,4 +38,3 @@ F# computation expressions give you an elegant syntax for compositional control - **Seamless error handling** with [railway-oriented programming](https://fsharpforfunandprofit.com/rop/) patterns - **Elegant data transformations** by hiding boilerplate and focusing on business logic - **Composable workflows** that can be combined and nested for complex operations - diff --git a/_snippets/domain_modelling.md b/_snippets/domain_modelling.md index d88f1ffb..c56b6542 100644 --- a/_snippets/domain_modelling.md +++ b/_snippets/domain_modelling.md @@ -37,6 +37,7 @@ code: | pp.Email --- ## Domain Models made Simple and Safe + F# gives you superb capabilities to create precise domain models that prevent errors at compile time. - **Discriminated unions** model each payment method with exactly the fields it needs @@ -44,4 +45,4 @@ F# gives you superb capabilities to create precise domain models that prevent er - **Exhaustive pattern matching** ensures every payment type is handled properly - **Type safety** catches errors at compile time that would be runtime bugs in other languages -By modeling your domain using F#'s algebraic data types, you create self-documenting code where the type system itself enforces business rules. This powerful technique shifts many bugs from runtime to compile time, dramatically improving software reliability. \ No newline at end of file +By modeling your domain using F#'s algebraic data types, you create self-documenting code where the type system itself enforces business rules. This powerful technique shifts many bugs from runtime to compile time, dramatically improving software reliability. diff --git a/_snippets/fable.md b/_snippets/fable.md index c141e0a9..447dfb30 100644 --- a/_snippets/fable.md +++ b/_snippets/fable.md @@ -39,4 +39,4 @@ F# is for both client and server. With [F# web technologies]({{ '/use/web-apps/' - **Full npm ecosystem access** with clean TypeScript-like interop - **Simplified async programming** with F#'s computation expressions for promises -F# brings its powerful type system and immutability to frontend development, eliminating common JavaScript bugs while maintaining full access to the JavaScript ecosystem. \ No newline at end of file +F# brings its powerful type system and immutability to frontend development, eliminating common JavaScript bugs while maintaining full access to the JavaScript ecosystem. diff --git a/_snippets/helloworld.md b/_snippets/helloworld.md index 4b20d575..d98d0504 100644 --- a/_snippets/helloworld.md +++ b/_snippets/helloworld.md @@ -18,11 +18,11 @@ code: | --- ## Concise like Python -F#'s elegant syntax and strong typing give you the tools to solve problems succinctly, robustly and happily. +F#'s elegant syntax and strong typing give you the tools to solve problems succinctly, robustly and happily. - **Concise syntax** defines reusable functions with minimal boilerplate - **Simple lists** uses indentation-based syntax without requiring commas - **String interpolation** provides readable string formatting with the `$` prefix - **Pipeline operator** creates a readable left-to-right flow of data -In just a few lines of code, F# provides a clean, readable implementation that would require significantly more boilerplate in many other languages. This expressive style becomes even more valuable as your programs grow in complexity. \ No newline at end of file +In just a few lines of code, F# provides a clean, readable implementation that would require significantly more boilerplate in many other languages. This expressive style becomes even more valuable as your programs grow in complexity. diff --git a/_snippets/oop.md b/_snippets/oop.md index 28ed4ca2..be1ec08c 100644 --- a/_snippets/oop.md +++ b/_snippets/oop.md @@ -47,4 +47,4 @@ F# is **functional first** and **immutable by default**, but it also provides pr - **Object expressions** provide lightweight implementation of interfaces without defining full classes - **Concise member syntax** keeps methods and properties clean and readable - **Automatic property generation** reduces boilerplate code for data-carrying types -- **Type extensions** let you add methods to existing types without inheritance \ No newline at end of file +- **Type extensions** let you add methods to existing types without inheritance diff --git a/_snippets/sequence_expressions.md b/_snippets/sequence_expressions.md index a60c8e9e..e5044a38 100644 --- a/_snippets/sequence_expressions.md +++ b/_snippets/sequence_expressions.md @@ -26,5 +26,5 @@ F# sequence expressions provide compositional, functional stream processing capa - **Simplified data generation** through sequence expressions - **Compositional data processing** through library routines -- **On-demand evaluation** of data streams +- **On-demand evaluation** of data streams - **Fluent, maintainable code** that is easy to read and understand diff --git a/_snippets/unitsOfMeasure.md b/_snippets/unitsOfMeasure.md index 37f2f7bf..f305985c 100644 --- a/_snippets/unitsOfMeasure.md +++ b/_snippets/unitsOfMeasure.md @@ -25,5 +25,3 @@ F# offers world-class compile-time unit safety without runtime overhead, giving - **Automatic unit conversions** maintain type safety while handling complex calculations - **Seamless interoperability** works with normal numeric types when needed - **Custom unit definitions** let you create your own units and conversions with simple syntax - - diff --git a/_testimonials/15below-1.md b/_testimonials/15below-1.md index e7155345..b09abd6d 100644 --- a/_testimonials/15below-1.md +++ b/_testimonials/15below-1.md @@ -6,16 +6,14 @@ bullets: keywords: [] quote: We would recommend F# as an additional tool in the kit of any company building software on the .NET stack. --- -Historically, our code base has been written in a mix of C# and VB.net. F#'s excellent interoperability +Historically, our code base has been written in a mix of C# and VB.net. F#'s excellent interoperability with the rest of .NET allows us to use it for components where it's particular strength's shine without having to discard or rewrite our existing code. -Whether it's driving the build and continuous integration system (due to scripting being a first -class citizen in the F# world) or writing rock solid infrastructure components (due to the easy -use of functional paradigms via features such as computational expressions, type inference and -discriminated unions) we have found our F# code to be concise, easy to write and reliable to use. +Whether it's driving the build and continuous integration system (due to scripting being a first +class citizen in the F# world) or writing rock solid infrastructure components (due to the easy +use of functional paradigms via features such as computational expressions, type inference and +discriminated unions) we have found our F# code to be concise, easy to write and reliable to use. It is a perfect fit for many components within our messaging based architecture. We would recommend it as an additional tool in the kit of any company building software on the .NET stack. - - \ No newline at end of file diff --git a/_testimonials/JamieDixon.md b/_testimonials/JamieDixon.md index 58be472a..1ef489f8 100644 --- a/_testimonials/JamieDixon.md +++ b/_testimonials/JamieDixon.md @@ -16,4 +16,3 @@ Also, I created a KNN classifier using the date/time of the stop and determined Finally, I did a public records request in the county in which I live: Wake County North Carolina. The dataset included appx 5,000 health inspection scores for 2012. Using F#, I did some basic statistical calculations to determine that there is little variance of when a restaurant gets inspected and their final score. An interesting offshoot is that some particular restaurants scored lower across all inspectors - except when head inspector did the inspection, then they actually scored better. There might an inherent cultural bias by the inspectors. You can read the entire analysis [here](http://jamessdixon.wordpress.com/2014/02/11/analysis-of-health-inspection-data-using-f/) F# was great because I spent less time figuring out how to answer my question and more time actually answering the question. The type providers made consuming and integrating hetrogenous datasets a snap and the pattern matching feature reduced the complexity of the code by an order of magnitude (compared to C#). Finally, by using unit tests and immutable data types, I have a bug-resistant code base that can be extended to other scenarios. - \ No newline at end of file diff --git a/_testimonials/advertisement-rating-and-ranking-at-microsoft.md b/_testimonials/advertisement-rating-and-ranking-at-microsoft.md index 1deac9c6..58a03527 100644 --- a/_testimonials/advertisement-rating-and-ranking-at-microsoft.md +++ b/_testimonials/advertisement-rating-and-ranking-at-microsoft.md @@ -12,10 +12,8 @@ keywords: - statistics quote: ' Around 95% of the code in these projects has been developed in F#' --- -Around 95% of the code in these projects has been developed in F#. F# allowed for rapid development +Around 95% of the code in these projects has been developed in F#. F# allowed for rapid development of prototypes, and thus also rapid verification or falsification of the underlying mathematical models. -Complex algorithms, for example to compute Nash equilibria in game theory, can be expressed -succinctly. Units of measure reduced the chance of errors dramatically: +Complex algorithms, for example to compute Nash equilibria in game theory, can be expressed +succinctly. Units of measure reduced the chance of errors dramatically: Prices, probabilities, derivatives, etc. can already be kept apart at compile time. - - \ No newline at end of file diff --git a/_testimonials/alex-hardwicke.md b/_testimonials/alex-hardwicke.md index 8ddbe1e2..c9cd566b 100644 --- a/_testimonials/alex-hardwicke.md +++ b/_testimonials/alex-hardwicke.md @@ -17,4 +17,3 @@ Users expect performant software with an always responsive UI, and frequently ex Using a modern, functional language that provides first-class support for things we need in modern development is a no-brainer. Immutability-first as a programming technique has fixed more bugs and bad code in my applications than almost anything else I've ever looked at, and it's something C# will never gain. It's not just C#, either. Many languages are evolving to be ready for the future, adding features that support the needs of a modern programming language, but F# is already there. - \ No newline at end of file diff --git a/_testimonials/andrew-phillips-1.md b/_testimonials/andrew-phillips-1.md index b6fcd378..5aaaaee3 100644 --- a/_testimonials/andrew-phillips-1.md +++ b/_testimonials/andrew-phillips-1.md @@ -15,26 +15,24 @@ keywords: quote: F# will continue to be our language of choice for scientific computing. --- I lead the Biological Computation group at Microsoft Research, where we are developing methods and -software for [modelling and analysis of biological systems](http://research.microsoft.com/biology). -We have been using F# in our group for the past 7 years, and it's the language of choice for all -of our software development. In particular it forms the basis of our software for programming -[computational circuits made of DNA](http://research.microsoft.com/dna), for programming -[genetic devices that operate inside cells](http://research.microsoft.com/gec), and for programming -[complex biological processes in a modular way](http://research.microsoft.com/spim). +software for [modelling and analysis of biological systems](http://research.microsoft.com/biology). +We have been using F# in our group for the past 7 years, and it's the language of choice for all +of our software development. In particular it forms the basis of our software for programming +[computational circuits made of DNA](http://research.microsoft.com/dna), for programming +[genetic devices that operate inside cells](http://research.microsoft.com/gec), and for programming +[complex biological processes in a modular way](http://research.microsoft.com/spim). -The functional data structures and static type-checking that F# provides are ideally suited for developing -these domain-specific languages, and the Visual Studio integration is superb for debugging -and source control. The integration with .Net is seamless, and allows us to incorporate -efficient numerical and visualisation libraries written in C#. It also allows us to -take advantage of the full suite of .Net UI components. +The functional data structures and static type-checking that F# provides are ideally suited for developing +these domain-specific languages, and the Visual Studio integration is superb for debugging +and source control. The integration with .Net is seamless, and allows us to incorporate +efficient numerical and visualisation libraries written in C#. It also allows us to +take advantage of the full suite of .Net UI components. -Our languages are specified with a formal syntax and semantics, which are rigorously -analysed prior to their implementation. Programming in a functional language like F# brings the implementation much closer to the -formal specification, which is important for ensuring accurate simulation and -probabilistic analysis. Correct implementation of the semantics is critical, since even -small coding errors can give rise to divergent predictions, which can in turn compromise -biological experiments. F# is a great language for writing clean, concise code, which is -statically typed within a professional development environment that supports a wealth of +Our languages are specified with a formal syntax and semantics, which are rigorously +analysed prior to their implementation. Programming in a functional language like F# brings the implementation much closer to the +formal specification, which is important for ensuring accurate simulation and +probabilistic analysis. Correct implementation of the semantics is critical, since even +small coding errors can give rise to divergent predictions, which can in turn compromise +biological experiments. F# is a great language for writing clean, concise code, which is +statically typed within a professional development environment that supports a wealth of libraries. It will continue to be our language of choice for scientific computing. - - \ No newline at end of file diff --git a/_testimonials/atalasoft.md b/_testimonials/atalasoft.md index bc3df6b7..bf1c3250 100644 --- a/_testimonials/atalasoft.md +++ b/_testimonials/atalasoft.md @@ -9,10 +9,9 @@ keywords: - immage processing quote: I evaluated F# and found that for certain tasks it was better than C# in terms of performance while maintaining suitable readability --- -I evaluated F# and found that for certain tasks it was better than C# in terms of performance -while maintaining suitable readability and for certain tasks, it leant itself better to certain -algorithms (OctTree based color quantization stands out). ...we were able to heavily leverage inline functions in F#......Since each of -these are inlines, the F# optimizer can actually do something useful with the code. By using F#, we were able to address this cost by using -inlining, code profiling, scanline caching, memoization and other techniques. In many cases we ended up with +I evaluated F# and found that for certain tasks it was better than C# in terms of performance +while maintaining suitable readability and for certain tasks, it leant itself better to certain +algorithms (OctTree based color quantization stands out). ...we were able to heavily leverage inline functions in F#......Since each of +these are inlines, the F# optimizer can actually do something useful with the code. By using F#, we were able to address this cost by using +inlining, code profiling, scanline caching, memoization and other techniques. In many cases we ended up with code that ran in equivalent time to C++ code or in some cases faster. - \ No newline at end of file diff --git a/_testimonials/aviva-flying-frog-1.md b/_testimonials/aviva-flying-frog-1.md index bc903e7e..47d7567c 100644 --- a/_testimonials/aviva-flying-frog-1.md +++ b/_testimonials/aviva-flying-frog-1.md @@ -9,20 +9,18 @@ keywords: - actuarial quote: Large insurance company developed an entire pension quote calculator entirely in F# in under 100 days with no prior F# experience at all... --- -One of the world's largest insurance companies have F# code in production, are starting several -more projects in F#. We are currently consulting for this company (£2.5bn profit) who have migrated -some of their number crunching and business logic to F# and are so happy with the results -(10x faster and 10x less code vs their Visual C++ 6) that they are proposing to migrate 1,600,000 lines of code to +One of the world's largest insurance companies have F# code in production, are starting several +more projects in F#. We are currently consulting for this company (£2.5bn profit) who have migrated +some of their number crunching and business logic to F# and are so happy with the results +(10x faster and 10x less code vs their Visual C++ 6) that they are proposing to migrate 1,600,000 lines of code to F#. In particular, their developers found F# easy to learn and use. -... my predecessor developed an entire pension quote calculator (typically scheduled to take 300-400 man days) -entirely in F# in under 100 days with no prior F# experience at all. Performance is 10× -better than the C++ that it replaces because the new code avoids unnecessary copying and exploits multicore +... my predecessor developed an entire pension quote calculator (typically scheduled to take 300-400 man days) +entirely in F# in under 100 days with no prior F# experience at all. Performance is 10× +better than the C++ that it replaces because the new code avoids unnecessary copying and exploits multicore parallelism. Part of my job here will be to give basic F# training to around 20 people and bring a few people up to expert level. -In answer to "Can you give any evidence for 10x performance gain over C++?". The insurer's C++ -code is a simple manual translation from very inefficient Mathematica code that suffers from several pathological -performance problems mainly centered around excessive copying. The F# rewrite does not have these problem. +In answer to "Can you give any evidence for 10x performance gain over C++?". The insurer's C++ +code is a simple manual translation from very inefficient Mathematica code that suffers from several pathological +performance problems mainly centered around excessive copying. The F# rewrite does not have these problem. The 10x performance gain was verified by the client. - - \ No newline at end of file diff --git a/_testimonials/bayard-rock-1.md b/_testimonials/bayard-rock-1.md index c129b629..27358a47 100644 --- a/_testimonials/bayard-rock-1.md +++ b/_testimonials/bayard-rock-1.md @@ -11,7 +11,5 @@ keywords: quote: 'The benefits of functional programming in F# have given us a great advantage over our slow moving competitors. ' --- At Bayard Rock we work hard every day in the pursuit of new approaches towards anti-money-laundering. Before adopting F# there were often months of turnaround time between development of an idea and actually testing it on real data in our production environment. F#’s succinctness and composability allows us to rapidly iterate on ideas while the type system acts as a safety net. On top of this, it has the advantage of being a first class member of the .NET ecosystem and so integrates seamlessly with our Microsoft stack systems. This means that instead of months we can often see our ideas come to life in just days. - + The benefits of functional programming in F# have given us a great advantage over our slow moving competitors. After three years of using F# our products have consistently gotten significantly better each year without sacrificing stability. Our clients often are amazed by how we can quickly adapt to unique challenges and how we can find the bad guys hiding in their data much more effectively than anyone else. Little do they know that it’s largely thanks to our secret weapon, F#. - - \ No newline at end of file diff --git a/_testimonials/bohdan-szymanik-1.md b/_testimonials/bohdan-szymanik-1.md index c9f15e20..2ad32821 100644 --- a/_testimonials/bohdan-szymanik-1.md +++ b/_testimonials/bohdan-szymanik-1.md @@ -8,9 +8,7 @@ keywords: - analysis quote: Bohdan ... shows F#'s use for performing aggregations over large datasets, taking advantage of CPU and IO parallelism --- -Bohdan Szymanik, CTO at Kiwibank, is keen to show how he's been using F# for analysis tasks -within the bank. He'll provide an intro to the language then show its use for performing -aggregations over large datasets, taking advantage of CPU and IO parallelism, and data +Bohdan Szymanik, CTO at Kiwibank, is keen to show how he's been using F# for analysis tasks +within the bank. He'll provide an intro to the language then show its use for performing +aggregations over large datasets, taking advantage of CPU and IO parallelism, and data presentation through charting and image generation. - - \ No newline at end of file diff --git a/_testimonials/boston-based-company.md b/_testimonials/boston-based-company.md index ed04a943..6dc0ef15 100644 --- a/_testimonials/boston-based-company.md +++ b/_testimonials/boston-based-company.md @@ -9,12 +9,10 @@ keywords: - financial services quote: F# encourages Reason Driven Development that leads to virtually bug-free code --- -We are using F# because it considerably increases speed of software development which is crucial -for a small company with limited development resources. The most enjoyable feature of this language -is that the developer can reason about the code instead of relying only on unit tests. -I would say the language encourages Reason Driven Development methodology which leads to -virtually bug-free code. F# as strongly typed functional language ideally fits for tasks our -software solves – Fixed Income securities trading optimization. It is also very important that -F# computation engine could be seamlessly integrated with other parts of .NET-based software product. - - \ No newline at end of file +We are using F# because it considerably increases speed of software development which is crucial +for a small company with limited development resources. The most enjoyable feature of this language +is that the developer can reason about the code instead of relying only on unit tests. +I would say the language encourages Reason Driven Development methodology which leads to +virtually bug-free code. F# as strongly typed functional language ideally fits for tasks our +software solves – Fixed Income securities trading optimization. It is also very important that +F# computation engine could be seamlessly integrated with other parts of .NET-based software product. diff --git a/_testimonials/byron-cook-1.md b/_testimonials/byron-cook-1.md index 6e4878e0..443e8ae5 100644 --- a/_testimonials/byron-cook-1.md +++ b/_testimonials/byron-cook-1.md @@ -11,7 +11,5 @@ keywords: quote: 'F# is the night vision goggles I need when I go into the dark and attempt to solve previously unsolved problems. ' --- I’m one of the first users of F#, since 2004. In my work (e.g. SLAM, Terminator, Zapato, T2, etc) -I find that F# is the night vision goggles I need when I go into the dark and attempt to solve +I find that F# is the night vision goggles I need when I go into the dark and attempt to solve previously unsolved problems. Everything becomes simple and clear when expressed in F#. - - \ No newline at end of file diff --git a/_testimonials/calitime.md b/_testimonials/calitime.md index bb382726..f6582170 100644 --- a/_testimonials/calitime.md +++ b/_testimonials/calitime.md @@ -7,7 +7,5 @@ keywords: [] quote: F# allow us to keep the code simple even in complicated business cases. --- TimeRocket is a service for attendance time tracking and absence- and shift-planning provided by Calitime AG. -The system runs on Azure, and we use F# on the ASP.NET backend and Azure Functions to program the business logic. +The system runs on Azure, and we use F# on the ASP.NET backend and Azure Functions to program the business logic. We like F# because discriminated unions, pattern matching, computation expressions and out-of-the-box equality allow us to keep the code simple even in complicated business cases. - - \ No newline at end of file diff --git a/_testimonials/can-erten.md b/_testimonials/can-erten.md index 14a62965..869882b3 100644 --- a/_testimonials/can-erten.md +++ b/_testimonials/can-erten.md @@ -15,4 +15,3 @@ Vector code is a code generator for iOS and OsX generating code in Objective C, F# is a first class language for Mac OsX. Thanks to the open source compiler, I was able to build a vector drawing, code generator software with F#. It is really amazing experience! The tooling is great and keeps improving. The compiler and the language are basically the same which is fantastic! F# is a powerful language and it is great to do cross platform development with it. I used heavily quotations for generating code in different languages on vector code. Powerful type system and static compilation meant that, once the application compiled without errors and warnings, it will just work and generate complete code. It did, and now at the App Store. - \ No newline at end of file diff --git a/_testimonials/cleartax.md b/_testimonials/cleartax.md index 3e4ab25e..1588c6e2 100644 --- a/_testimonials/cleartax.md +++ b/_testimonials/cleartax.md @@ -14,5 +14,3 @@ quote: At ClearTax, We have built a whole product from the ground-up in F#. It's The expressiveness and power of F# has resulted in shorter build cycles, simpler business logic (with fewer bugs!) and the ability to quickly evolve the product. Type Providers have let us add support for a lot of data formats (Government formats, Excel files, third party sources) very quickly. Pattern matching has made it possible to simplify complex business logic. F# has been a joy to work with, and we're using it more and more throughout our products now. - - \ No newline at end of file diff --git a/_testimonials/cme-1.md b/_testimonials/cme-1.md index f1c3b593..0d0aa01c 100644 --- a/_testimonials/cme-1.md +++ b/_testimonials/cme-1.md @@ -9,11 +9,11 @@ keywords: - portfolio analysis quote: The efficient use of functional programming throughout the R&D cycle helped make the cycle faster and more efficient. --- -The credit markets have varying pockets of liquidity. Market participants would like to understand how the -liquidity of their set of entities changes relative to the overall market. A liquidity scoring model is -needed to provide these metrics across the entire CDS universe. Functional programming and specifically -F# was used in order to provide the market with a fast and accurate solution. ... The research and development cycle was made faster and more efficient by the effective use of -functional programming. +The credit markets have varying pockets of liquidity. Market participants would like to understand how the +liquidity of their set of entities changes relative to the overall market. A liquidity scoring model is +needed to provide these metrics across the entire CDS universe. Functional programming and specifically +F# was used in order to provide the market with a fast and accurate solution. ... The research and development cycle was made faster and more efficient by the effective use of +functional programming. The efficient use of functional programming throughout the R&D cycle helped make the cycle faster and more efficient. Less time was spent on translating requirements, miscommunications etc and more on producing a fast and accurate solution quickly. @@ -22,5 +22,3 @@ Since programmers can understand your quant code they can focus on their core co The development exercise becomes catered towards optimization, performance tuning and error handling (i.e. making the code reliable) Functionality is not lost from the prototype due to miscommunication or rather crude documentation/requirements, which saves time in testing. Mass regression testing is easy with precise precision level differences between the prototype and the production system. - - \ No newline at end of file diff --git a/_testimonials/compositional-it.md b/_testimonials/compositional-it.md index 2eaac015..ed7b5c9d 100644 --- a/_testimonials/compositional-it.md +++ b/_testimonials/compositional-it.md @@ -12,4 +12,3 @@ keywords: quote: On a release of a complex rules engine and data transformation system to one of our customers, we were delighted to hear that across 90+ markets, not one of them found any issues with any of the calculations in the datasets. F# just works. --- As a consultancy geared towards delivering solutions to customers in a variety of sectors, we rely on F# for all of our solutions, whether it's a rules engine, a distributed and scalable data transformation system on Azure or a customer-facing web application. I love the fact that we have confidence in our deliverables thanks in no small part to the pit of success that F# leads us down; we very, very rarely encounted bugs that we saw time and again with other languages and frameworks. At the same time, we're able to consistently deliver to our customers much more quickly than we might have done otherwise - a key value proposition for many of our customers who often need a short time to market. - \ No newline at end of file diff --git a/_testimonials/credit-suisse-abstract.md b/_testimonials/credit-suisse-abstract.md index d95fcbe7..196a69ce 100644 --- a/_testimonials/credit-suisse-abstract.md +++ b/_testimonials/credit-suisse-abstract.md @@ -12,12 +12,10 @@ keywords: - financial modelling quote: At Credit Suisse, we've been using F# to develop quantitative models for financial products --- -Building valuation models for derivative trades requires rapid development of mathematical models, made possible by -composition of lower-level model components. We have found that F#, with the associated toolset, provides a -unique combination of features that make it very well suited to this kind of development. In this talk, I will explain how we -are using F# and show why it is a good match. I will also talk about the problems we have had, +Building valuation models for derivative trades requires rapid development of mathematical models, made possible by +composition of lower-level model components. We have found that F#, with the associated toolset, provides a +unique combination of features that make it very well suited to this kind of development. In this talk, I will explain how we +are using F# and show why it is a good match. I will also talk about the problems we have had, and outline future enhancements that would benefit this kind of work. The abstract to [a talk at the Commercial Users of Functional Programming workshop](http://cufp.org/archive/2008/abstracts.html#MansellHoward) - - \ No newline at end of file diff --git a/_testimonials/dario.md b/_testimonials/dario.md index c5204b45..91c8e71a 100644 --- a/_testimonials/dario.md +++ b/_testimonials/dario.md @@ -8,9 +8,8 @@ keywords: - immutability quote: '...your code is less error-prone...' --- -You can formulate many problems much easier, closer to their definition and more concise in a -functional programming language like F# and your code is less error-prone (immutability, more powerful type system, intuitive recurive algorithms). -You can code what you mean instead of what the computer wants you to say ;-) Furthermore you -can have F# and C# together in one solution, so you can combine the benefits of both +You can formulate many problems much easier, closer to their definition and more concise in a +functional programming language like F# and your code is less error-prone (immutability, more powerful type system, intuitive recurive algorithms). +You can code what you mean instead of what the computer wants you to say ;-) Furthermore you +can have F# and C# together in one solution, so you can combine the benefits of both languages and use them where they're needed. - \ No newline at end of file diff --git a/_testimonials/darren-platt-1.md b/_testimonials/darren-platt-1.md index bbcac850..908f570e 100644 --- a/_testimonials/darren-platt-1.md +++ b/_testimonials/darren-platt-1.md @@ -10,23 +10,21 @@ keywords: - bioinformatics quote: F# rocks... building out various algorithms for DNA processing here and it's like a drug --- -With F#... we have written a complete genome re-sequencing pipeline with interface, algorithms, +With F#... we have written a complete genome re-sequencing pipeline with interface, algorithms, reporting in ~5K lines and it has been incredibly reliable, fast and easy to maintain. -F# rocks - we're building out various algorithms for DNA processing here and it's like a drug. Just -implemented a suffix tree in 150 lines that can index 200,000 bases a second ;) We have probably -10-20K lines of code for many scientific applications ranging from a full genome sequencing -pipeline that reconstructs and annotated yeast strains, to simulators for various processes -and design tools for building DNA sequences/constructs. There are lab located apps that +F# rocks - we're building out various algorithms for DNA processing here and it's like a drug. Just +implemented a suffix tree in 150 lines that can index 200,000 bases a second ;) We have probably +10-20K lines of code for many scientific applications ranging from a full genome sequencing +pipeline that reconstructs and annotated yeast strains, to simulators for various processes +and design tools for building DNA sequences/constructs. There are lab located apps that grab robot log files and move them to databases and a tool for viewing a huge collection of DNA sequencing data. F# has been phenomenally useful. I would be writing a lot of this in Python otherwise and F# is more robust, 20x - 100x faster to run and for anything but the most trivial programs, faster to develop. -The UI work is especially gratifying, because state of the art for a lot of genomic data display -is still PNG images embedded in JavaScript and with F# I can render half a million data points on +The UI work is especially gratifying, because state of the art for a lot of genomic data display +is still PNG images embedded in JavaScript and with F# I can render half a million data points on a web page without jumping through hoops. With Units of Measure I started labelling the coordinates as one or zero based and immediately found a bug where I'd casually mixed the two systems. Yay F#! - - \ No newline at end of file diff --git a/_testimonials/david-walker-1.md b/_testimonials/david-walker-1.md index e1f57a4d..90aac9ce 100644 --- a/_testimonials/david-walker-1.md +++ b/_testimonials/david-walker-1.md @@ -10,11 +10,9 @@ keywords: - cross-platform quote: 'F#...made it trivial... ' --- -Our graduate course on Parallelism this Fall is full, even though it assumes no -experience with functional programming or F#. The students are preparing the courseware -themselves, and one of the topics we are studying is functional reactive programming (FRP) -with continuous, time-varying behaviors. F#, with its rich graphics libraries, made it -trivial to construct a super-fun assignment involving purely functional and interactive +Our graduate course on Parallelism this Fall is full, even though it assumes no +experience with functional programming or F#. The students are preparing the courseware +themselves, and one of the topics we are studying is functional reactive programming (FRP) +with continuous, time-varying behaviors. F#, with its rich graphics libraries, made it +trivial to construct a super-fun assignment involving purely functional and interactive animation of a mock solar system. - - \ No newline at end of file diff --git a/_testimonials/deyan-petrov.md b/_testimonials/deyan-petrov.md index f680b0f6..138bf957 100644 --- a/_testimonials/deyan-petrov.md +++ b/_testimonials/deyan-petrov.md @@ -7,12 +7,10 @@ keywords: - safe quote: F# brought correct defaults, simplicity and safety back to our coding --- -A couple of years ago we started a greenfield project with backend (microservices) 100% written in F#. The language allowed/allows us to deliver a lot with a very small team, resulting in a concise and easily maintainable codebase. +A couple of years ago we started a greenfield project with backend (microservices) 100% written in F#. The language allowed/allows us to deliver a lot with a very small team, resulting in a concise and easily maintainable codebase. We are solely focusing on the basics - functions and records, and shying away from OOP or any other complicated constructs. Among the "exotic" features of F# we use are only a few [computational expressions](https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/computation-expressions) - Async, AsyncResult, Result, as well as the [units of measures](https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/units-of-measure) for strongly-typing GUIDs and other domain attributes. Even Dependency Injections we with straightforward [partial application](https://fsharpforfunandprofit.com/posts/partial-application/) unstead of using the sophisticated Reader monad or similar. -Being a member of the .NET family F# still gives us access to .NET BCL and any (performance) improvements of it, as well as to all 3rd-party libraries written in C# (e.g. Azure SDKs, sftp, email clients and many others). +Being a member of the .NET family F# still gives us access to .NET BCL and any (performance) improvements of it, as well as to all 3rd-party libraries written in C# (e.g. Azure SDKs, sftp, email clients and many others). Onboarding of new team members (usually with C# background) has been pretty easy and quick. - - \ No newline at end of file diff --git a/_testimonials/dmitry-soshnikov-1.md b/_testimonials/dmitry-soshnikov-1.md index 872c57ab..1ff2a84c 100644 --- a/_testimonials/dmitry-soshnikov-1.md +++ b/_testimonials/dmitry-soshnikov-1.md @@ -6,11 +6,9 @@ bullets: keywords: [] quote: There is a noticeable interest in the developer community in Russia towards F#. --- -I do some samples in F# for the lectures and the book, but all that is within a single-user -VS 2010 Pro installation. Right now we have a set of slides on functional programming with -F# in Russian in the curriculum repository, and the video-course of functional programming -using F# available in the largest Russian Internet-University (intuit.ru). The course -is being taught in 2 universities. There is a noticeable interest in the developer community in +I do some samples in F# for the lectures and the book, but all that is within a single-user +VS 2010 Pro installation. Right now we have a set of slides on functional programming with +F# in Russian in the curriculum repository, and the video-course of functional programming +using F# available in the largest Russian Internet-University (intuit.ru). The course +is being taught in 2 universities. There is a noticeable interest in the developer community in Russia towards F#. - - \ No newline at end of file diff --git a/_testimonials/doctors-lab.md b/_testimonials/doctors-lab.md index b241aa1e..ff4ff215 100644 --- a/_testimonials/doctors-lab.md +++ b/_testimonials/doctors-lab.md @@ -10,9 +10,8 @@ keywords: - etl quote: I could not recommend F# highly enough – I insist that you try it! --- -The Doctors Laboratory is the largest independent provider of clinical laboratory diagnostic services in the UK. We use F# for the majority of our in house development, from ETL tasks, via reporting scripts to full web applications. +The Doctors Laboratory is the largest independent provider of clinical laboratory diagnostic services in the UK. We use F# for the majority of our in house development, from ETL tasks, via reporting scripts to full web applications. F#’s idiomatic development style, starting with a script in the REPL, before moving functions into a more structured project, makes it trivial to explore different approaches, refactor &c. before committing to a particular approach. It also makes developing more enjoyable and direct – there’s no need to get all the boiler plate/plumbing in place; you can just create a script and start coding. The compiler’s type inference system also means quicker coding, with less ‘cruft’. Features such as pattern matching and discriminated unions also lead to leaner, more expressive and transparent code. Type providers mean data can be accessed in a few lines, and there are a wealth of community driven OSS projects available here for a heterogeneous range of data sources. If you need to access a data source not supported by existing providers, then the community positively encourages getting involved to provide one yourself, as in fact we did with the MSACCESS provider for the SQLProvider type provider. The community is first rate in terms of providing support in forums like Stack Overflow, gitter, etc. Other community projects such as Paket (dependency management) and FAKE (build too) make build automation a breeze, too. - \ No newline at end of file diff --git a/_testimonials/dsyme-ad-predict-1.md b/_testimonials/dsyme-ad-predict-1.md index 1ec47785..d528365a 100644 --- a/_testimonials/dsyme-ad-predict-1.md +++ b/_testimonials/dsyme-ad-predict-1.md @@ -11,14 +11,12 @@ keywords: - prediction quote: F#'s powerful type inference means less typing, more thinking --- -F# was used on Microsoft's AdPredict project for adCenter. This was a 4 week project with 4 machine learning experts involving a model -with 100 million probabilistic variables and processing 6TB of training data in real-time. 2 weeks of CPU time -were used during training. Benefits included **Quick Coding** - F#'s powerful type inference means less typing, more thinking, +F# was used on Microsoft's AdPredict project for adCenter. This was a 4 week project with 4 machine learning experts involving a model +with 100 million probabilistic variables and processing 6TB of training data in real-time. 2 weeks of CPU time +were used during training. Benefits included **Quick Coding** - F#'s powerful type inference means less typing, more thinking, **Agile Coding** - Type-inferred code is easily refactored, **Scripting** - "Hands-on" exploration, **Performance** - Immediate scaling to massive data sets, **Memory-Faithful** - Mega-data structures on 16GB machines, **Succinctness** - Live in the domain, not the language, **Symbolic** - Schema compilation and "Schedules" and **.NET Integration** - Especially Excel, SQL Server - - \ No newline at end of file diff --git a/_testimonials/dylan-hutchinson-intern-1.md b/_testimonials/dylan-hutchinson-intern-1.md index 28c69a53..5802d9c5 100644 --- a/_testimonials/dylan-hutchinson-intern-1.md +++ b/_testimonials/dylan-hutchinson-intern-1.md @@ -13,4 +13,3 @@ quote: My team chose F# for its functional paradigm, maturity, and ease of inter With an idea for a new domain specific language, my team chose F# for its functional paradigm, maturity, and ease of interoperation with the .NET framework. I wrote the language primitives in F#’s arsenal of data types (records, discriminated unions, a couple classes at the top level), implemented operations on the types using its hierarchy of modules, and turned our operations into a working demo in F# Interactive, all in about 10 days. I jumped for joy each time my code executed correctly on the first pass, and in the few cases it did not, debugging through Visual Studio felt natural and quick. As for .NET, integrating with Microsoft Excel was easy by importing the necessary DLLs, though Excel posed challenges beyond F#’s reach. Finally, I can verify that F# delivers a sense of correctness and safety, stronger than other languages I worked with in the past. It is reassuring to know your code will execute exactly as you intend. - \ No newline at end of file diff --git a/_testimonials/early-warning-1.md b/_testimonials/early-warning-1.md index f808fe67..ca9ff3a2 100644 --- a/_testimonials/early-warning-1.md +++ b/_testimonials/early-warning-1.md @@ -6,20 +6,18 @@ bullets: keywords: [] quote: At a major Investment Bank, we used F# to build an Early Warning Indicator System for Liquidity Risk --- -Early Warning Indicators is a standalone dashboard application to monitor real-time market -movements and highlight potential risk for further analysis. EWI subscribed to real-time equity, -Forex and commodity prices and needed to calculate Red/Amber/Green status in real-time for +Early Warning Indicators is a standalone dashboard application to monitor real-time market +movements and highlight potential risk for further analysis. EWI subscribed to real-time equity, +Forex and commodity prices and needed to calculate Red/Amber/Green status in real-time for tolerance breaches and to generate dashboard reports as needed. The business wanted the flexibility to define formulas using Excel expressions, but spreadsheet -components could not cope with the data-rate without conflation and management didn’t want a +components could not cope with the data-rate without conflation and management didn’t want a solution that relied on an Excel template and IT change control to add new indicators. -F# was chosen for development productivity, performance of a cell framework implemented using -computation expressions; ease with which Excel expressions could be parsed as a DSL and .NET +F# was chosen for development productivity, performance of a cell framework implemented using +computation expressions; ease with which Excel expressions could be parsed as a DSL and .NET integration with QALib, Market and timer-series data. -Post implementation review highlighted that (given resource and time constraints) functionality +Post implementation review highlighted that (given resource and time constraints) functionality would have been sacrificed without F# and its associated tooling. - - \ No newline at end of file diff --git a/_testimonials/emea.md b/_testimonials/emea.md index 474cf72c..ec828e24 100644 --- a/_testimonials/emea.md +++ b/_testimonials/emea.md @@ -7,11 +7,10 @@ keywords: - integration quote: '...we have decided to use F# as our functional language to have automatic integration with rest of the system...' --- -We develop security product to protect critical infrastructure (e.g. Oil Refinery, Airport, etc) for countries across -the globe.... In core of our product there are prediction algorithms. We use different modeling and theorems -(Monte Carlo, Action, etc) to implement the prediction components. ... Since we are rewriting our next generation product -using .NET, we have decided to use F# as functional language to have automatic integration with rest of the system. ... We -also have advanced machine learning components (Artificial Intelligence) and functional languages are the -best fit to write AI stuff. We are planning to use F# as the primary programming language in this -area because of its interoperability with .NET. - \ No newline at end of file +We develop security product to protect critical infrastructure (e.g. Oil Refinery, Airport, etc) for countries across +the globe.... In core of our product there are prediction algorithms. We use different modeling and theorems +(Monte Carlo, Action, etc) to implement the prediction components. ... Since we are rewriting our next generation product +using .NET, we have decided to use F# as functional language to have automatic integration with rest of the system. ... We +also have advanced machine learning components (Artificial Intelligence) and functional languages are the +best fit to write AI stuff. We are planning to use F# as the primary programming language in this +area because of its interoperability with .NET. diff --git a/_testimonials/financial-services-1.md b/_testimonials/financial-services-1.md index a09e7e82..1ff04010 100644 --- a/_testimonials/financial-services-1.md +++ b/_testimonials/financial-services-1.md @@ -10,8 +10,7 @@ keywords: - fixed income quote: With its new tools, the bank can speed development by 50 percent or more, improve quality, and reduce costs. --- -A large financial services firm in Europe sought new development tools that could cut costs, boost productivity, - and improve the quality of its mathematical models. To address its needs, the bank deployed F#, the - .NET Framework, and Visual Studio. It will soon upgrade to Visual Studio 2010 and then integrated +A large financial services firm in Europe sought new development tools that could cut costs, boost productivity, + and improve the quality of its mathematical models. To address its needs, the bank deployed F#, the + .NET Framework, and Visual Studio. It will soon upgrade to Visual Studio 2010 and then integrated F#. With its new tools, the bank can speed development by 50 percent or more, improve quality, and reduce costs. - \ No newline at end of file diff --git a/_testimonials/giuseppe-maggiore.md b/_testimonials/giuseppe-maggiore.md index 867712d0..b7adbd47 100644 --- a/_testimonials/giuseppe-maggiore.md +++ b/_testimonials/giuseppe-maggiore.md @@ -8,5 +8,3 @@ quote: I can tell you, F# really saved us a ton of effort. --- I am the lead developer of Galaxy Wars, and I can tell you, F# really saved us a ton of effort. Monadic coroutines alone I believe are the reason why we manage to ship the thing on time... - - \ No newline at end of file diff --git a/_testimonials/goswin-1.md b/_testimonials/goswin-1.md index a1f1511e..78801a36 100644 --- a/_testimonials/goswin-1.md +++ b/_testimonials/goswin-1.md @@ -18,5 +18,3 @@ In recent years many Architects have discovered that they can greatly enlarge th One such project is the *Louvre Abu Dhabi* by Jean Nouvel. Waagner-Biro was awarded the construction contract for the Dome. For the cladding of this dome more than 450´000 individual cutting and drilling patterns of custom aluminium extrusions had to be described and automated. The sheer scale and complexity of the cladding on the dome required us to re-evaluate our parametric design approach. I developed an F# application to represent and organize all cladding elements of the dome. It includes a small geometry kernel and an adapted version of the Half Edge Data Structure to efficiently query the neighbourhood of each element. I used Rhino and its .NET API to host the F# DLL for drawing and visualisation. This application enabled us to have an integrated workflow from the main geometry setout all the way down to the manufacturing data in a single parametric model. This project was the first use of F# at Waagner-Biro for a large scale project. The switch to F# from dynamic scripting languages helped to reduce development time and execution time. The strongly typed environment, algebraic data types and immutable data helped to avoid a whole range of bugs and fits well the domain of generating static 3d geometry. I see great potential for F# to be used as scripting languages in CAD, especially since most big CAD packages already offer a .NET API. (Image credits: Jean Nouvel Architects) - - \ No newline at end of file diff --git a/_testimonials/grange-insurance-1.md b/_testimonials/grange-insurance-1.md index 33b7c2d7..d752c6cc 100644 --- a/_testimonials/grange-insurance-1.md +++ b/_testimonials/grange-insurance-1.md @@ -8,13 +8,11 @@ keywords: - financial services quote: Grange Insurance parallelized its rating engine to take better advantage of multicore server hardware --- -For nearly 75 years, Grange Insurance has offered competitive products and services to policyholders -in more than a dozen U.S. states. To maintain its well-earned reputation and standing, the company decided to -enhance its rating engine—a software tool for rating policies and performing what-if modeling, impact analyses, -and other vital activities. Working with the Sophic Group and using the Microsoft Visual Studio Team System development +For nearly 75 years, Grange Insurance has offered competitive products and services to policyholders +in more than a dozen U.S. states. To maintain its well-earned reputation and standing, the company decided to +enhance its rating engine—a software tool for rating policies and performing what-if modeling, impact analyses, +and other vital activities. Working with the Sophic Group and using the Microsoft Visual Studio Team System development environment and F# programming language, Grange Insurance parallelized its rating engine to take -better advantage of multicore server hardware, and in so doing garnered significant performance benefits. -Processes that used to require hours now take just minutes, enabling the company to trim time-to-market +better advantage of multicore server hardware, and in so doing garnered significant performance benefits. +Processes that used to require hours now take just minutes, enabling the company to trim time-to-market by weeks and making it far easier for independent agents to sell and service Grange products. - - \ No newline at end of file diff --git a/_testimonials/green-eagle-solutions.md b/_testimonials/green-eagle-solutions.md index 77941aab..f6809e5f 100644 --- a/_testimonials/green-eagle-solutions.md +++ b/_testimonials/green-eagle-solutions.md @@ -17,4 +17,3 @@ Beforehand, we used Python to quickly build simulators to test our components. W We have also started to use F# directly in our components to implementing the core logic, while leaving C# to networking tasks. We've taking advantage of this language mix to create a dependency injector which recompiles the F# logic at runtime whenever the script changes for quick development iterations, but loads a precompiled .dll when deployed in production. The double nature of F# as a scripting and a compiled language really shines here. F#'s terse syntax made the final code look really similar to the algorithm we wrote at first in formal language. Also, we've come to really appreciate the numerous metaprogramming libraries in the F# ecosystem: we particularly like FSharp.Formatting and have started to adopt the literate programming style to integrate as much as possible the code and the documentation and prevent them losing sync. - \ No newline at end of file diff --git a/_testimonials/handelsbanken-1.md b/_testimonials/handelsbanken-1.md index c41bd911..33c4e0f8 100644 --- a/_testimonials/handelsbanken-1.md +++ b/_testimonials/handelsbanken-1.md @@ -13,33 +13,31 @@ keywords: - financial modelling quote: The performance is phenomenal. We can now re-calculate the entire bank portfolio from scratch in less than a second and the response-time for single deal verification calculation is far below 100 milliseconds. --- -I first evaluated F# back in 2006 - 2007 for the purpose of math oriented high performance applications within -Financial Risk. I got in spring 2009 a mission to implement a new Real-time Counter-party Risk system covering -all possible present and future deal types within the entire bank. The effort was started with only three -resources, me as architect and lead developer and two colleagues – one risk expert and one high performing -developer. Our first intention was to use C#, but I did a quick proof-of-concept with F# implementing a low -level TCP/IP-communication to an existing risk-system. This showed us and our management that F# could give -us a real productivity boost due to its support for multiple paradigms and functional concepts together with -an impressive support for multi-threading. +I first evaluated F# back in 2006 - 2007 for the purpose of math oriented high performance applications within +Financial Risk. I got in spring 2009 a mission to implement a new Real-time Counter-party Risk system covering +all possible present and future deal types within the entire bank. The effort was started with only three +resources, me as architect and lead developer and two colleagues – one risk expert and one high performing +developer. Our first intention was to use C#, but I did a quick proof-of-concept with F# implementing a low +level TCP/IP-communication to an existing risk-system. This showed us and our management that F# could give +us a real productivity boost due to its support for multiple paradigms and functional concepts together with +an impressive support for multi-threading. -Our first delivery is approaching rapidly and F# has proved itself as a real life-saver. We started off using -C# in many places but have since then moved almost entirely into F# due to its ability to reduce the amount of -code required and its simplicity when developing massive parallel computations. The performance is phenomenal. -We can now re-calculate the entire bank portfolio from scratch in less than a second and the response-time for -single deal verification calculation is far below 100 milliseconds(the original demand was 200 milliseconds to -make the application usable for electronic markets). Although some gains are to be attributed to how we have built -our calculation models, F# made it possible for us to implement our algorithms and techniques with very little code -and with a huge similarity to the original mathematical models and regulations (which is important for verification -of correctness). We have also been able to use the support for Async-workflows producing code that is simple and -clear and easy to understand but still runs in parallel when required. +Our first delivery is approaching rapidly and F# has proved itself as a real life-saver. We started off using +C# in many places but have since then moved almost entirely into F# due to its ability to reduce the amount of +code required and its simplicity when developing massive parallel computations. The performance is phenomenal. +We can now re-calculate the entire bank portfolio from scratch in less than a second and the response-time for +single deal verification calculation is far below 100 milliseconds(the original demand was 200 milliseconds to +make the application usable for electronic markets). Although some gains are to be attributed to how we have built +our calculation models, F# made it possible for us to implement our algorithms and techniques with very little code +and with a huge similarity to the original mathematical models and regulations (which is important for verification +of correctness). We have also been able to use the support for Async-workflows producing code that is simple and +clear and easy to understand but still runs in parallel when required. -The present application contains 35 to 40.000 lines of F#-code and an equal amount of C#-code. However, our -estimate is that the F# code contains at least 80% of the functionality (which is pretty amazing!). Our experience -shows us that the number of code lines shrinks with a ratio of 1/2 to 1/4 by just porting functionality from -C# to F# (not counting single character or empty lines in the C#-code). We have by remodeling increased the -ratio to the area of 1/5 to 1/8, where the remodeling involves replacing object oriented constructs with -functional ones (and actually removing mutable states). One example from last week was a limit-utilization -module written in F# but using an object-oriented approach containing +300 lines of code. I rewrote it to +The present application contains 35 to 40.000 lines of F#-code and an equal amount of C#-code. However, our +estimate is that the F# code contains at least 80% of the functionality (which is pretty amazing!). Our experience +shows us that the number of code lines shrinks with a ratio of 1/2 to 1/4 by just porting functionality from +C# to F# (not counting single character or empty lines in the C#-code). We have by remodeling increased the +ratio to the area of 1/5 to 1/8, where the remodeling involves replacing object oriented constructs with +functional ones (and actually removing mutable states). One example from last week was a limit-utilization +module written in F# but using an object-oriented approach containing +300 lines of code. I rewrote it to below 70 lines of code just by shifting paradigm (and the rewrite made it much easier to understand and verify)! - - \ No newline at end of file diff --git a/_testimonials/hans-rischel.md b/_testimonials/hans-rischel.md index e119b5dc..64e3c9a8 100644 --- a/_testimonials/hans-rischel.md +++ b/_testimonials/hans-rischel.md @@ -6,29 +6,27 @@ bullets: keywords: [] quote: Solving a number of programming problems using the language convinced me of the supreme qualities of F# --- -I was approached by my former colleague Michael (Michael R. Hansen) in autumn -2010 where he proposed that we should write a new textbook on functional -programming - now using the F# programming language. To begin with I was quite -sceptical about using a programming language appearing as part of a Microsoft -program package. Solving a number of programming problems using the language -convinced me, however, of the supreme qualities of F# - and we embarked on -the project of getting acquainted with F# and writing the textbook. +I was approached by my former colleague Michael (Michael R. Hansen) in autumn +2010 where he proposed that we should write a new textbook on functional +programming - now using the F# programming language. To begin with I was quite +sceptical about using a programming language appearing as part of a Microsoft +program package. Solving a number of programming problems using the language +convinced me, however, of the supreme qualities of F# - and we embarked on +the project of getting acquainted with F# and writing the textbook. -Michael and I spent considerable time solving traditional programming -problems in F#. A combination of functional and imperative F# with an -occasional pinch of OO gives a very pleasing platform for program -development - once you have found your way through the wilderness of MSDN -documentation (newcomers to the MSDN world may benefit from the -MSDN library documentation found on the [web-site of the book](http://www2.compute.dtu.dk/~mire/FSharpBook/index.html). -All of Chapter 10 and part of Chapter 11 present program examples using +Michael and I spent considerable time solving traditional programming +problems in F#. A combination of functional and imperative F# with an +occasional pinch of OO gives a very pleasing platform for program +development - once you have found your way through the wilderness of MSDN +documentation (newcomers to the MSDN world may benefit from the +MSDN library documentation found on the [web-site of the book](http://www2.compute.dtu.dk/~mire/FSharpBook/index.html). +All of Chapter 10 and part of Chapter 11 present program examples using this programming style. -Computation expressions look esoteric to begin with, but they are actually -rather useful. We spent much time -trying to get this concept down to earth, with the purpose of making it accessible -to simple-minded people like ourselves. The reader may judge how far we -succeeded by studying Chapter 12 of the book. +Computation expressions look esoteric to begin with, but they are actually +rather useful. We spent much time +trying to get this concept down to earth, with the purpose of making it accessible +to simple-minded people like ourselves. The reader may judge how far we +succeeded by studying Chapter 12 of the book. Writing this textbook with Michael has been an exciting experience. - - \ No newline at end of file diff --git a/_testimonials/horspool-1.md b/_testimonials/horspool-1.md index 496cc043..5c2371ec 100644 --- a/_testimonials/horspool-1.md +++ b/_testimonials/horspool-1.md @@ -9,9 +9,7 @@ keywords: - research quote: When F# is combined with Visual Studio... productivity goes through the roof! --- -F# programs tend to be much shorter than their equivalents in other languages. The -fewer lines of code required, of course, the higher the productivity. When F# is combined -with Visual Studio, which provides help with remembering the methods attached to different +F# programs tend to be much shorter than their equivalents in other languages. The +fewer lines of code required, of course, the higher the productivity. When F# is combined +with Visual Studio, which provides help with remembering the methods attached to different data types and how to use those methods, productivity goes through the roof! - - \ No newline at end of file diff --git a/_testimonials/insurello.md b/_testimonials/insurello.md index 0049429e..6a37a954 100644 --- a/_testimonials/insurello.md +++ b/_testimonials/insurello.md @@ -14,4 +14,3 @@ keywords: quote: The compiler and the use of exhaustive pattern matching have saved us from what could’ve been many mistakes in production. --- At Insurello, F# lets us model complicated business data with a lightweight syntax in a way that feels closer to reality. The type system helps us avoid creating impossible states and enables us to focus on the business problems. The compiler and the use of exhaustive pattern matching have saved us from what could’ve been many mistakes in production. F# is “just the right amount of FP” which helps us write simple and maintainable code and makes it easy to onboard people, even those with no background in Functional Programming. - \ No newline at end of file diff --git a/_testimonials/james-moore.md b/_testimonials/james-moore.md index 27a07f80..33f1ae7b 100644 --- a/_testimonials/james-moore.md +++ b/_testimonials/james-moore.md @@ -17,5 +17,3 @@ multithreaded system that was easily portable between Android and iOS. Our F# actors (shared across iOS and Android) expose .Net IObservables that are consumed by UI systems written for the native platforms. Dividing the system in that way allowed for testable multithreaded code that would have been difficult to write in other .Net languages. - - \ No newline at end of file diff --git a/_testimonials/jared-parsons-1.md b/_testimonials/jared-parsons-1.md index 3f0c2ac5..2beb33d5 100644 --- a/_testimonials/jared-parsons-1.md +++ b/_testimonials/jared-parsons-1.md @@ -8,9 +8,8 @@ keywords: - conciseness quote: '...I have to say I love the language...' --- -Over the last 6 or so months, I've been working on a Vim emulation layer. This is the first major project I've ever done with F# -and I have to say I love the language. In many ways I used this project as a method of learning -F# (and this learning curve is very much evident if you look through the history of the project). -What I find the most amazing about F# is just how concise of a language it is. The Vim engine comprises +Over the last 6 or so months, I've been working on a Vim emulation layer. This is the first major project I've ever done with F# +and I have to say I love the language. In many ways I used this project as a method of learning +F# (and this learning curve is very much evident if you look through the history of the project). +What I find the most amazing about F# is just how concise of a language it is. The Vim engine comprises the bulk of the logic yet it only comprises 30% of the overall code base. - \ No newline at end of file diff --git a/_testimonials/jon-canning.md b/_testimonials/jon-canning.md index f7278ec3..70018a03 100644 --- a/_testimonials/jon-canning.md +++ b/_testimonials/jon-canning.md @@ -9,5 +9,3 @@ quote: Type providers made working with external data sources simple and intuiti Every day we analyze data for hundreds of thousand of properties, sourced from XML and JSON feeds. Features such as Options and Type Providers have given us incredibly concise, expressive, and testable code with which to handle them, freeing us to focus on business value. As a developer moving from C#, some of the concepts you read about functional programming can be difficult to grasp and the barrier to entry appears high. However, with just a basic understanding and a helpful and welcoming community, F# has proven to be very productive and has quickly become my language of choice. - - \ No newline at end of file diff --git a/_testimonials/jorge-fioranelli.md b/_testimonials/jorge-fioranelli.md index 7624041a..55245afb 100644 --- a/_testimonials/jorge-fioranelli.md +++ b/_testimonials/jorge-fioranelli.md @@ -10,9 +10,8 @@ keywords: - mvc quote: F# allowed us to mix Domain-Driven Design, Functional Programming and Azure to deliver a high quality web application. --- -The site amancai.com.au was built combining F#, Domain-Driven Desing, Asp.Net MVC and Azure. F# was an excellent choice as it allowed us to keep the code lean and very functional while having full access to the BCL, Azure and third party libraries. +The site amancai.com.au was built combining F#, Domain-Driven Desing, Asp.Net MVC and Azure. F# was an excellent choice as it allowed us to keep the code lean and very functional while having full access to the BCL, Azure and third party libraries. -Using F# Type Providers also helped us to improve our productivity and find problems early during the development process. +Using F# Type Providers also helped us to improve our productivity and find problems early during the development process. I personally enjoyed the experience of building the entire system using F#, I believe its "functional-first" approach is excellent for building a wide range of applications. - \ No newline at end of file diff --git a/_testimonials/jozef-rudy.md b/_testimonials/jozef-rudy.md index 3208cb6d..225a8981 100644 --- a/_testimonials/jozef-rudy.md +++ b/_testimonials/jozef-rudy.md @@ -22,4 +22,4 @@ It parses subset of Typescript into F# interpretable AST, which can later be eva Because parsing with Fparsec went so well I later gradually migrated entire project into F# (from C#). The beauty of this approach is that I don't need any specialized F# libraries - I can stay very close to the original (C#) dotnet server, avoiding dependency on specialized F# third-party packages. -I can still use great dotnet server features like background jobs or dependency injection. \ No newline at end of file +I can still use great dotnet server features like background jobs or dependency injection. diff --git a/_testimonials/kaggle-1.md b/_testimonials/kaggle-1.md index 5433667a..8f5bc6ff 100644 --- a/_testimonials/kaggle-1.md +++ b/_testimonials/kaggle-1.md @@ -8,15 +8,14 @@ keywords: - startup quote: The F# code is consistently shorter, easier to read, easier to refactor and contains far fewer bugs. As our data analysis tools have developed ... we've become more productive. --- -At Kaggle we initially chose F# for our core data analysis algorithms because of its expressiveness. -We've been so happy with the choice that we've found ourselves moving more and more of -our application out of C# and into F#. The F# code is consistently shorter, easier to read, +At Kaggle we initially chose F# for our core data analysis algorithms because of its expressiveness. +We've been so happy with the choice that we've found ourselves moving more and more of +our application out of C# and into F#. The F# code is consistently shorter, easier to read, easier to refactor, and, because of the strong typing, contains far fewer bugs. -As our data analysis tools have developed, we've seen domain-specific constructs -emerge very naturally; as our codebase gets larger, we become more productive. +As our data analysis tools have developed, we've seen domain-specific constructs +emerge very naturally; as our codebase gets larger, we become more productive. -The fact that F# targets the CLR was also critical - even though we have a large existing -code base in C#, getting started with F# was an easy decision because +The fact that F# targets the CLR was also critical - even though we have a large existing +code base in C#, getting started with F# was an easy decision because we knew we could use new modules right away. - \ No newline at end of file diff --git a/_testimonials/lemball-1.md b/_testimonials/lemball-1.md index 1e7d4274..dde3c4f9 100644 --- a/_testimonials/lemball-1.md +++ b/_testimonials/lemball-1.md @@ -12,16 +12,14 @@ keywords: - correctness quote: The results speak for themselves. --- -As a business we actively seek improvement every single day. This is the same for our IT systems, +As a business we actively seek improvement every single day. This is the same for our IT systems, so we have been searching for a means to do that in our in-house software systems. -The F# type system has allowed us to do this - by eliminating null references, increasing type -safety and creating rich domain models that help us express hard-and-fast business rules in a -way that we can really lean on the compiler; while actually reducing our total lines of code -(and noise!). Doing so has reduced both our requirement for expensive bug hunts in our +The F# type system has allowed us to do this - by eliminating null references, increasing type +safety and creating rich domain models that help us express hard-and-fast business rules in a +way that we can really lean on the compiler; while actually reducing our total lines of code +(and noise!). Doing so has reduced both our requirement for expensive bug hunts in our production systems, and the overall cost of maintaining unnecessary code complexity. -We have been evaluating F# for a year now, and have components in our production systems that +We have been evaluating F# for a year now, and have components in our production systems that have been bug-free since deployment. The results speak for themselves. - - \ No newline at end of file diff --git a/_testimonials/london-based-company.md b/_testimonials/london-based-company.md index 1ec3de27..f45c4f53 100644 --- a/_testimonials/london-based-company.md +++ b/_testimonials/london-based-company.md @@ -10,10 +10,8 @@ keywords: - derivatives quote: ' I keep being surprised by how compact and readable F# is...' --- -We have set up a complete risk management system that combines several data sources, presents them in a ... -WPF user interface, and does a LOT of calculation behind the scenes. When the calculation -requires a proper algorithm (i.e. anything that is more complex than a simple for loop), -our choice has been F#. I have to say I keep being surprised by how compact it is and, nonetheless, +We have set up a complete risk management system that combines several data sources, presents them in a ... +WPF user interface, and does a LOT of calculation behind the scenes. When the calculation +requires a proper algorithm (i.e. anything that is more complex than a simple for loop), +our choice has been F#. I have to say I keep being surprised by how compact it is and, nonetheless, how readable it is even when I'm reading code that I hadn't looked at or thought about for six months. - - \ No newline at end of file diff --git a/_testimonials/lula.md b/_testimonials/lula.md index 3d0d50c5..86ccd732 100644 --- a/_testimonials/lula.md +++ b/_testimonials/lula.md @@ -13,5 +13,3 @@ quote: The sensible defaults (immutability, non-nullability, algebraic data type At Lula, we have found F# to be an excellent choice for building domain-driven APIs to service the insurance industry. The sensible defaults (immutability, non-nullability, algebraic data types, etc.) along with the power of the F# compiler enables our team to quickly and concisely develop systems. The developer experience and tooling is top-tier and the ecosystem is rich and vast, thanks to F# targeting the .NET platform. In addition, the nature of the type system moves an entire class of errors from being runtime errors to compile-time errors. I would recommend any software engineer that cares about their craft to take the time and learn F#...not only will it make you a better developer, you will have some fun along the way! - - \ No newline at end of file diff --git a/_testimonials/mangel-maxime.md b/_testimonials/mangel-maxime.md index 4f595009..b0835c42 100644 --- a/_testimonials/mangel-maxime.md +++ b/_testimonials/mangel-maxime.md @@ -10,4 +10,3 @@ Since I started programming, I tested a lot of languages. I used PHP, JavaScript The tooling for the language is great and also this language is really supported by is community and I love that. And finally, F# is a language with which I've become really efficient and I find that if I write a code the type inference assures me correctness. I am still waiting for the first bug to appear in my production app. - \ No newline at end of file diff --git a/_testimonials/maria-gorinova.md b/_testimonials/maria-gorinova.md index 86f2d89a..7196f625 100644 --- a/_testimonials/maria-gorinova.md +++ b/_testimonials/maria-gorinova.md @@ -10,4 +10,3 @@ keywords: quote: Programming in F# feels like writing out ideas rather than code --- When I started working on the T2 temporal logic prover, I knew little about termination analysis and formal verification. F# made it easy to dive into these concepts and boosted my productivity by allowing me to write clean, concise, and accurate programs. Its functional nature, clear syntax and type inference is combined with the flexibility to write in an imperative style and use the .NET framework. This combination powerfully bridges the gap between thinking about a concept and implementing it. Programming in F# feels like writing out ideas rather than code. - \ No newline at end of file diff --git a/_testimonials/mario-pereira.md b/_testimonials/mario-pereira.md index 23a9828c..8a63f475 100644 --- a/_testimonials/mario-pereira.md +++ b/_testimonials/mario-pereira.md @@ -19,7 +19,7 @@ F# and experience its immense expressive power, its delightful syntax and realize they can do functional programming (which is oftenly taken as something boring and complicated) on a familiar and confortable environment. Currently, along with a fellow portuguese -MSP, (following the success of previous presentations and in response +MSP, (following the success of previous presentations and in response to the many requests for new sessions on F#) I'm preparing an hands-on session on the use of F# for Cryptography, to be presented on a future event at Microsoft Portugal. @@ -28,5 +28,3 @@ reliable and complex applications on a confortable and succinct way, impossible to achieve with other languages and paradigms. With no doubt, I can say I'm a huge fan of F# and I'm always eager to get in touch with every new feature the language has to offer. - - \ No newline at end of file diff --git a/_testimonials/mauricio-scheffer.md b/_testimonials/mauricio-scheffer.md index ccc9197e..6e1b22ee 100644 --- a/_testimonials/mauricio-scheffer.md +++ b/_testimonials/mauricio-scheffer.md @@ -12,4 +12,3 @@ I’ve been using F# libraries in otherwise mostly C# / VB.NET web applications. Furthermore, F#’s succinct syntax and REPL make it an excellent scripting language and good for data exploration. Thanks to F#’s interoperability the scripts can easily use domains and libraries written in C#. You never need to start from scratch or have to reinvent things. Language features like record types, discriminated unions and type inference also make F# a great language for prototyping. I often prototype new business domains in F# with a few simplified use cases to refine it. The simple syntax allows me to focus on developing the domain and iterate more quickly. Then, when company policy requires it, I translate it to C# which is usually a straightforward process that ends up with many times more lines of code (yet still perfectly maintainable). - \ No newline at end of file diff --git a/_testimonials/miccrosoft-engineering-1.md b/_testimonials/miccrosoft-engineering-1.md index 877ac474..e5a475e0 100644 --- a/_testimonials/miccrosoft-engineering-1.md +++ b/_testimonials/miccrosoft-engineering-1.md @@ -11,8 +11,7 @@ keywords: quote: In our engineering group at Microsoft we use F# for several projects --- In our internal engineering group at Microsoft, F# is used for several important tools: -* analyzing feedback on the web to look for compatibility-related issues, -* a static code analyzer to detect compatibility regressions in a product, -* a delta-debugging tool to help root cause regression analysis in product builds. - \ No newline at end of file +* analyzing feedback on the web to look for compatibility-related issues, +* a static code analyzer to detect compatibility regressions in a product, +* a delta-debugging tool to help root cause regression analysis in product builds. diff --git a/_testimonials/michael-hansen.md b/_testimonials/michael-hansen.md index dc4a370d..5cc221fe 100644 --- a/_testimonials/michael-hansen.md +++ b/_testimonials/michael-hansen.md @@ -27,5 +27,3 @@ interpreter for a rich imperative programming language, another being implementation, application and analysis of a functional pearl, and the last being a curriculum planning system for studies at the Technical University of Denmark. - - \ No newline at end of file diff --git a/_testimonials/microsoft-narwhal-1.md b/_testimonials/microsoft-narwhal-1.md index d808544b..a89eda85 100644 --- a/_testimonials/microsoft-narwhal-1.md +++ b/_testimonials/microsoft-narwhal-1.md @@ -9,8 +9,7 @@ keywords: - Microsoft quote: '...We use F# in oceanographic research to connect multiple visualizations together in time and space...' --- -We use F# in oceanographic research to connect multiple visualizations together in time and space, which is map-plane location and depth. We began by building our Narwhal Developers Library for Layerscape -in C# with emphasis on visualizing flow lines and understanding drift experiment data. These data are quite complex, involving physical ocean state and measurement of microbial metabolic processes, consolidating remote sensing and passive drifters, and adding to all this current measurements with the tracks of autonomous robots. Our technical term for the visualization challenge is ‘horrible’. +We use F# in oceanographic research to connect multiple visualizations together in time and space, which is map-plane location and depth. We began by building our Narwhal Developers Library for Layerscape +in C# with emphasis on visualizing flow lines and understanding drift experiment data. These data are quite complex, involving physical ocean state and measurement of microbial metabolic processes, consolidating remote sensing and passive drifters, and adding to all this current measurements with the tracks of autonomous robots. Our technical term for the visualization challenge is ‘horrible’. To cope with the horrible we began adding F# scripts; and this has been extremely productive, particularly in morphing ideas about data exploration into real tools quickly. Our most interesting achievement to date is to wire a chart into a 4D visual environment. The set-up is like this: The scientist sees two views of the data: First color coded structure in a curtain plot of time versus depth (chlorophyll coded as color for example), and second this same data time-boxed in the dynamic Worldwide Telescope (WWT) visualization engine. F# is used to wire them together: Left click (and drag) in the chart to scroll the WWT clock back and forth. Right-click + drag in the chart to select a subset of the data which is then used to construct a new (small) advection visualization. Because the selected pieces are small and chosen interactively we get around the horrible problem of seeing everything at once. It is like seeing an entire forest and making all but a few curious trees vanish. So F# has been a great way to make rapid progress, and fun to learn as well. - \ No newline at end of file diff --git a/_testimonials/microsoft-quantum-1.md b/_testimonials/microsoft-quantum-1.md index 8ec1d981..ee868e05 100644 --- a/_testimonials/microsoft-quantum-1.md +++ b/_testimonials/microsoft-quantum-1.md @@ -10,16 +10,15 @@ keywords: - modelling quote: F# is central to Microsoft’s quantum algorithm research --- -F# is central to Microsoft’s quantum algorithm research. The LIQUi|⟩ simulator (Language -Integrated Quantum Operations) presents an extension of F# that presents a -seamless integration of classical and quantum operations. The scale and efficiency -of the simulator allows it to handle among the largest entangled -systems of qubits (quantum bits) ever modeled utilizing a targeted linear algebra package -written entirely in F#. In addition, the modular architecture allows users to -easily extend the system in any desired research direction. The base library is -well over 20,000 lines of code and implements a wide range of modules including -circuits, molecular modeling, spin-glass systems, quantum error correction, machine -learning, factoring and many others. The system runs in client, server and cloud -environments. It is also designed to be used as an educational tool and we have +F# is central to Microsoft’s quantum algorithm research. The LIQUi|⟩ simulator (Language +Integrated Quantum Operations) presents an extension of F# that presents a +seamless integration of classical and quantum operations. The scale and efficiency +of the simulator allows it to handle among the largest entangled +systems of qubits (quantum bits) ever modeled utilizing a targeted linear algebra package +written entirely in F#. In addition, the modular architecture allows users to +easily extend the system in any desired research direction. The base library is +well over 20,000 lines of code and implements a wide range of modules including +circuits, molecular modeling, spin-glass systems, quantum error correction, machine +learning, factoring and many others. The system runs in client, server and cloud +environments. It is also designed to be used as an educational tool and we have found that bringing new users up to speed is a quick and painless process. - \ No newline at end of file diff --git a/_testimonials/namigop.md b/_testimonials/namigop.md index 53f2efa2..305e37b8 100644 --- a/_testimonials/namigop.md +++ b/_testimonials/namigop.md @@ -10,6 +10,4 @@ keywords: quote: it is fun language to code in --- I've written two commercial apps in F#, WcfStorm.Rest and WcfStorm.Server. -The UI part was in C# and the library part was in F#. In my experience it is fun language to code in. - - \ No newline at end of file +The UI part was in C# and the library part was in F#. In my experience it is fun language to code in. diff --git a/_testimonials/oconnors-1.md b/_testimonials/oconnors-1.md index b90f8e4a..f11d08ab 100644 --- a/_testimonials/oconnors-1.md +++ b/_testimonials/oconnors-1.md @@ -14,19 +14,17 @@ keywords: - asp.net quote: F# was so easy to pick up we went from complete novices to having our code in production in less than a week. --- -As an experiment to evaluate functional programming as a production tool we developed a +As an experiment to evaluate functional programming as a production tool we developed a new multi level caching system for our website in F#. Because F# can use existing C# -libaries so easily we were able to proceed rapidly using popular packages such as +libaries so easily we were able to proceed rapidly using popular packages such as StackExchange.Redis and ProtoBuf-Net. In less than a week we had a flexible caching -system in production, complete with an administration page and performance statistics +system in production, complete with an administration page and performance statistics tracking. -We also found that it was straightforward to use our new F# module from within our -existing C# code, and that the F# code deployed to and ran as an Azure app service +We also found that it was straightforward to use our new F# module from within our +existing C# code, and that the F# code deployed to and ran as an Azure app service without any special configuration. Adding F# to the code base was completely painless. - -The developers on our team are all intrigued by F# and eager to learn more. As well, -we find that at college recruiting events, prospective students are very excited to hear -that we are using a functional language in production - \ No newline at end of file +The developers on our team are all intrigued by F# and eager to learn more. As well, +we find that at college recruiting events, prospective students are very excited to hear +that we are using a functional language in production diff --git a/_testimonials/path-of-go.md b/_testimonials/path-of-go.md index 7e4825eb..68bb8879 100644 --- a/_testimonials/path-of-go.md +++ b/_testimonials/path-of-go.md @@ -10,9 +10,7 @@ keywords: - TrueSkill quote: '...The AI is implemented in F#...' --- -Path of Go is powered by three technologies...: an AI capable of playing Go, the F# language, -and TrueSkill to match online players. The AI is implemented in F# and meets the challenge of -running efficiently in the .net compact framework on Xbox 360. This game places you in a number of +Path of Go is powered by three technologies...: an AI capable of playing Go, the F# language, +and TrueSkill to match online players. The AI is implemented in F# and meets the challenge of +running efficiently in the .net compact framework on Xbox 360. This game places you in a number of visually stunning 3D scenes. It was fully developed in managed code using the XNA environment. - - \ No newline at end of file diff --git a/_testimonials/peter-sestoft-1.md b/_testimonials/peter-sestoft-1.md index e7463a06..5d675cc0 100644 --- a/_testimonials/peter-sestoft-1.md +++ b/_testimonials/peter-sestoft-1.md @@ -9,10 +9,8 @@ keywords: - cross-platform quote: "...That's the reason we have chosen F# for our undergraduate functional programming class..." --- -F# has a beautiful, simple but expressive language at its core, and many powerful features -built around that core language. It can draw on all the power of the .NET libraries, -and runs on Windows, MacOS and Linux. That's the reason we have chosen F# for our -undergraduate functional programming class as well as our +F# has a beautiful, simple but expressive language at its core, and many powerful features +built around that core language. It can draw on all the power of the .NET libraries, +and runs on Windows, MacOS and Linux. That's the reason we have chosen F# for our +undergraduate functional programming class as well as our undergraduate programming language class [(link)](http://www.itu.dk/people/sestoft/plc/) - - \ No newline at end of file diff --git a/_testimonials/prolucid.md b/_testimonials/prolucid.md index 5948f4c6..5bba016c 100644 --- a/_testimonials/prolucid.md +++ b/_testimonials/prolucid.md @@ -15,4 +15,3 @@ Prolucid delivers solutions to customers in markets ranging from Medical Devices Our E2C reference architecture has been developed around small F# core and offers platform independence, linear scalability and easy of customization. F# allowed us to leverage the .NET expertise many of us had and combine it with the elegance of functional programming to provide real-time connectivity, event processing and complex analytics solutions for out customers. We have open-sourced some of this work and you can find it on [GitHub](https://github.com/prolucid). - \ No newline at end of file diff --git a/_testimonials/reminder-hero.md b/_testimonials/reminder-hero.md index 408680a4..74be9826 100644 --- a/_testimonials/reminder-hero.md +++ b/_testimonials/reminder-hero.md @@ -16,4 +16,3 @@ functional nature of the language makes it easy to ensure that our code is testa Our first iterations were written in C#, but after switching to F#, we saw a drastic reduction in code size, along with an increase in readability. We'll definitely be sticking with F# for all of our future projects. - \ No newline at end of file diff --git a/_testimonials/robert-boissy.md b/_testimonials/robert-boissy.md index 6adda82f..b89c7068 100644 --- a/_testimonials/robert-boissy.md +++ b/_testimonials/robert-boissy.md @@ -12,21 +12,20 @@ keywords: - simulation quote: Many attributes of the F# programming language make it an ideal choice for ...the exponentially growing volumes of molecular analysis data --- -I am involved in bioinformatics and computational genomics as a faculty member at the -University of Nebraska Medical Center (UNMC). In an academic medical center like UNMC there -are heavy demands on my time and a wide range of different types of research projects that +I am involved in bioinformatics and computational genomics as a faculty member at the +University of Nebraska Medical Center (UNMC). In an academic medical center like UNMC there +are heavy demands on my time and a wide range of different types of research projects that I can end up working on. I have used the F# programming language -for several of these projects, including one that involved a very productive +for several of these projects, including one that involved a very productive collaboration with IntelliFactory and the use of WebSharper. -You can visit the resulting [web site](http://app1.unmc.edu/fgx) and read the freely -available peer-reviewed scientific publication that describes the important -[infectious disease research](http://mbio.asm.org/content/4/1/e00537-12.long) -that this F# software development project facilitates. I am always interested in -opportunities to work with professional software development enterprises whose teams include -developers with F# expertise, because I believe that many attributes of the F# programming -language make it an ideal choice for the development of software solutions that integrate -Electronic Health Record (EHR) data and the exponentially growing volumes of molecular analysis +You can visit the resulting [web site](http://app1.unmc.edu/fgx) and read the freely +available peer-reviewed scientific publication that describes the important +[infectious disease research](http://mbio.asm.org/content/4/1/e00537-12.long) +that this F# software development project facilitates. I am always interested in +opportunities to work with professional software development enterprises whose teams include +developers with F# expertise, because I believe that many attributes of the F# programming +language make it an ideal choice for the development of software solutions that integrate +Electronic Health Record (EHR) data and the exponentially growing volumes of molecular analysis data that can now be obtained from individual patients (e.g., personal genome DNA sequencing data). There's an exciting future for F# in this huge, emerging, data-rich health care market. - \ No newline at end of file diff --git a/_testimonials/simao-sousa-1.md b/_testimonials/simao-sousa-1.md index 532743d3..215a2276 100644 --- a/_testimonials/simao-sousa-1.md +++ b/_testimonials/simao-sousa-1.md @@ -9,18 +9,16 @@ keywords: - cross-platform quote: F# is very popular among my students for the programming projects --- -I teach and use OCaml and F# in my lectures (Theory of Computation, Formal Languages and Compiler -Design, Formal Methods, Applied Cryptography), and F# is very popular among my students for the -programming projects. Most of the students that are supervised by me (undergraduate, master +I teach and use OCaml and F# in my lectures (Theory of Computation, Formal Languages and Compiler +Design, Formal Methods, Applied Cryptography), and F# is very popular among my students for the +programming projects. Most of the students that are supervised by me (undergraduate, master but also PhD) use F# as the underlying programming language. This is even more the case now since -part of our research directions includes working on cloud/distributed systems. +part of our research directions includes working on cloud/distributed systems. -F# and its programming environment leverage with no doubt the ability and the productivity of my -students. This is, in my opinion, for two main reasons. First, F# allows the student, but also the +F# and its programming environment leverage with no doubt the ability and the productivity of my +students. This is, in my opinion, for two main reasons. First, F# allows the student, but also the researcher like me, to focus on the key aspects of his creation, while, secondly, enhancing -technologically the work done in a so remarkable and facilitated way. Once drawn in paper and pencil, +technologically the work done in a so remarkable and facilitated way. Once drawn in paper and pencil, an algorithm is naturally implemented in F# and easily deployed in whatever is its execution context. I am definitively a strong believer of F# and amazed by the language and its community. - - \ No newline at end of file diff --git a/_testimonials/simard-1.md b/_testimonials/simard-1.md index 473194bc..a79954be 100644 --- a/_testimonials/simard-1.md +++ b/_testimonials/simard-1.md @@ -14,36 +14,35 @@ quote: 'For a machine learning scientist, speed of experimentation is the critic --- I wrote the first prototype of the click prediction system deployed in Microsoft AdCenter in F# in a few days. -For a machine learning scientist, speed of experimentation is the critical factor to optimize. Compiling is -fast but loading large amounts of data in memory takes a long time. With F#’s REPL, you only need to load the -data once and you can then code and explore in the interactive environment. Unlike C# and C++, F# was designed -for this mode of interaction. It has the ease of use of Matlab or Python, both of which I have used extensively -in the past. One problem with Matlab and Python is that they are not strongly typed. No compile-time type -checking hurts speed of experimentation because of bugs, lack of reusability, high cost of refactoring, no -intellisense, and slow execution. Switching to F# was liberating and exhilarating. 2 caveats: Not every -problem fits that model. With a bit of discipline, such as avoiding massive parallelism for as long as -possible, the model goes a long way. The second caveat is that the cost of learning F# is steep. For me, it +For a machine learning scientist, speed of experimentation is the critical factor to optimize. Compiling is +fast but loading large amounts of data in memory takes a long time. With F#’s REPL, you only need to load the +data once and you can then code and explore in the interactive environment. Unlike C# and C++, F# was designed +for this mode of interaction. It has the ease of use of Matlab or Python, both of which I have used extensively +in the past. One problem with Matlab and Python is that they are not strongly typed. No compile-time type +checking hurts speed of experimentation because of bugs, lack of reusability, high cost of refactoring, no +intellisense, and slow execution. Switching to F# was liberating and exhilarating. 2 caveats: Not every +problem fits that model. With a bit of discipline, such as avoiding massive parallelism for as long as +possible, the model goes a long way. The second caveat is that the cost of learning F# is steep. For me, it was 2 weeks of decreased productivity. It has proven a worthwhile investment. -As a machine learning practitioner programming in F#, I constantly switch between two activities: -1) writing prototype code (highly interactive ugly code with throw away results, functions, and visualizations) -and 2) upgrading prototype code to library standard (fast, generic, reusable). When I go back to writing -prototypes, I build on top of the newly upgraded functions. In F#, the cost of switching between these two +As a machine learning practitioner programming in F#, I constantly switch between two activities: + +1) writing prototype code (highly interactive ugly code with throw away results, functions, and visualizations) +and 2) upgrading prototype code to library standard (fast, generic, reusable). When I go back to writing +prototypes, I build on top of the newly upgraded functions. In F#, the cost of switching between these two modes is minimal: often nothing needs to be done other than adding comments and deleting deprecated functions. -This means that most of the time is dedicated to experimenting and the majority of the code is close to shipping +This means that most of the time is dedicated to experimenting and the majority of the code is close to shipping quality. Some people can do this in C# or Matlab, but I find that F# excels at it. -I started F# with deep suspicions regarding efficiency. My first test was to link F# with C++/CLI and -check performance of calling SSE/AVX optimized code. As hoped, F# is comparable to C# when it comes to -speed. You have the same flexibility to link with well optimized code. The inline generics are truly +I started F# with deep suspicions regarding efficiency. My first test was to link F# with C++/CLI and +check performance of calling SSE/AVX optimized code. As hoped, F# is comparable to C# when it comes to +speed. You have the same flexibility to link with well optimized code. The inline generics are truly magical: same IL in the linked DLLs, but the functions expand to specialized fast code when you instantiate -them. Compromises between intuitive code and efficient code still need to be made. I found that “for” loop, -“tail recursive” loop, or Parallel.For with ThreadLocal loops, are faster than a succession of piped IEnumerables +them. Compromises between intuitive code and efficient code still need to be made. I found that “for” loop, +“tail recursive” loop, or Parallel.For with ThreadLocal loops, are faster than a succession of piped IEnumerables (seq in F#). F# does not hamper one’s ability to write ugly fast code. Rest assured. -Several people in the machine learning group in Microsoft Research have switched to F# for the reasons -above. The world is slowly moving toward functional programming with good justifications: the code is -cleaner and easier to debug in a distributed environment. Among the available functional languages, F# +Several people in the machine learning group in Microsoft Research have switched to F# for the reasons +above. The world is slowly moving toward functional programming with good justifications: the code is +cleaner and easier to debug in a distributed environment. Among the available functional languages, F# is a compelling option. - - \ No newline at end of file diff --git a/_testimonials/simon-cousins-1.md b/_testimonials/simon-cousins-1.md index d70dbeea..262ee922 100644 --- a/_testimonials/simon-cousins-1.md +++ b/_testimonials/simon-cousins-1.md @@ -12,12 +12,10 @@ keywords: - load quote: The use of F# demonstrates a sweet spot for the language within enterprise software --- -I have written an application to balance the national power generation schedule for a portfolio -of power stations to a trading position for an energy company. The client and server components -were in C# but the calculation engine was written in F#. +I have written an application to balance the national power generation schedule for a portfolio +of power stations to a trading position for an energy company. The client and server components +were in C# but the calculation engine was written in F#. -The use of F# to address the complexity at the heart of this application clearly demonstrates -a sweet spot for the language within enterprise software, namely algorithmically complex +The use of F# to address the complexity at the heart of this application clearly demonstrates +a sweet spot for the language within enterprise software, namely algorithmically complex analysis of large data sets. My experience has been a very positive one. - - \ No newline at end of file diff --git a/_testimonials/simon-cousins-2.md b/_testimonials/simon-cousins-2.md index 2fca44c2..5d5688f3 100644 --- a/_testimonials/simon-cousins-2.md +++ b/_testimonials/simon-cousins-2.md @@ -11,14 +11,12 @@ keywords: - ETL quote: I have now delivered three business critical projects written in F#. I am still waiting for the first bug to come in. --- -I am both a C# dev and an F# dev. I can only offer subjective anecdotal evidence based -on my experience of delivering projects in both languages (I am too busy delivering -software to do anything else). +I am both a C# dev and an F# dev. I can only offer subjective anecdotal evidence based +on my experience of delivering projects in both languages (I am too busy delivering +software to do anything else). -That said, the one stat in the summary that I find most compelling is the defect rate. -I have now delivered three business critical projects written in F#. I am still waiting -for the first bug to come in. This is not the case with the C# projects I have delivered. -I will continue to monitor and report on this. It might be that I am just on a lucky streak, +That said, the one stat in the summary that I find most compelling is the defect rate. +I have now delivered three business critical projects written in F#. I am still waiting +for the first bug to come in. This is not the case with the C# projects I have delivered. +I will continue to monitor and report on this. It might be that I am just on a lucky streak, but I suspect that the clarity and concision of F# code contributes greatly to its correctness. - - \ No newline at end of file diff --git a/_testimonials/sledilnik-1.md b/_testimonials/sledilnik-1.md index 34377259..6859caeb 100644 --- a/_testimonials/sledilnik-1.md +++ b/_testimonials/sledilnik-1.md @@ -13,5 +13,3 @@ Covid-19 Tracker Slovenia is a community-driven open source project that collect We use F#/Fable/Feliz for front-end visualization, and F# has proven to be a very good choice for this fast-moving, decentralized project. The majority of people contributing code have never used a functional programming language or even heard of F#. Nevertheless, most contributors were able to quickly navigate the code and develop their own visualizations with little or no orientation and very few bugs or runtime issues. By using F# and its strong type system, we were able to keep the code base consistent and easily adaptable to this ever-evolving and growing project. And the excellent Fable and Feliz projects allowed easy and smooth integration into the JavaScript ecosystem. - - \ No newline at end of file diff --git a/_testimonials/stephen-kennedy.md b/_testimonials/stephen-kennedy.md index b88e4fa7..0dbf48be 100644 --- a/_testimonials/stephen-kennedy.md +++ b/_testimonials/stephen-kennedy.md @@ -13,7 +13,6 @@ I was consulting at engagement for a large multi-national organization that prod F# was chosen over C# as it provided a large number of language features related to mapping out of the box. Code quotations, discriminated unions, partial application, matching, and active patterns were used extensively. Having objects immutable by default made the logic very deterministic and easy to maintain / follow. -I was incredibly happy with the results, particularly with the declarative nature I could use to describe the various mappings, and their relationship with other mappings. This should make it much easier for other developers and the business analysts to figure out what logic is executed when a particular mapping occurs. The core logic saw a big reduction in code size, however, the real saving was in the entity specific mapping logic which saw the lines of code required go down by more than 90 percent! +I was incredibly happy with the results, particularly with the declarative nature I could use to describe the various mappings, and their relationship with other mappings. This should make it much easier for other developers and the business analysts to figure out what logic is executed when a particular mapping occurs. The core logic saw a big reduction in code size, however, the real saving was in the entity specific mapping logic which saw the lines of code required go down by more than 90 percent! F# is definitely a language I will be recommending to clients going forward. - \ No newline at end of file diff --git a/_testimonials/susan-eisenbach-1.md b/_testimonials/susan-eisenbach-1.md index 1dd3553e..e2fcc1f5 100644 --- a/_testimonials/susan-eisenbach-1.md +++ b/_testimonials/susan-eisenbach-1.md @@ -10,10 +10,8 @@ keywords: - cross-platform quote: F#...levels the playing field between beginners and experienced programmers. --- -Functional languages are ideal for teaching clear thinking, for solving problems -amenable to code solutions and it levels the playing field between beginners and -experienced programmers. The first programming language taught has a substantial -influence on what language students use when they have a free choice. F#, once it -is platform independent, has the potential to become the first programming language. - - \ No newline at end of file +Functional languages are ideal for teaching clear thinking, for solving problems +amenable to code solutions and it levels the playing field between beginners and +experienced programmers. The first programming language taught has a substantial +influence on what language students use when they have a free choice. F#, once it +is platform independent, has the potential to become the first programming language. diff --git a/_testimonials/synctoday-1.md b/_testimonials/synctoday-1.md index e23e0f76..b3df26fa 100644 --- a/_testimonials/synctoday-1.md +++ b/_testimonials/synctoday-1.md @@ -11,9 +11,7 @@ quote: '"Speed. I am speed." works for F# like a charm.' We felt our C# Sync.Today 2013 started to become a huge monster with all the C# scripting, hooks etc. At the same time it was not really providing us with the flexibility we needed to fulfil our customers' requirements. Instead of just another round of refactoring we decided to start moving to F# with Sync.Today 2015. Since both languages share the same -common CLR, we did not throw everything away. We just started to simplify more and more because the F# code +common CLR, we did not throw everything away. We just started to simplify more and more because the F# code has much less lines (we had 146831x "{ or }", 56555x "Blank", 2770x "Null checks", 56194x "Comments" and finally 223502 "Useful lines" and now we have 30602 lines with an order of magnitude more features and benefits ) Since we are processing a lot of information, but without complex computations etc., Orleans became the distributed computing library we build the solution on. It is using mixed C# + F# code now, which is perfect for us and allow us to run both on-premise and in Azure. - - \ No newline at end of file diff --git a/_testimonials/tabbles-1.md b/_testimonials/tabbles-1.md index 06d978dd..4dab2860 100644 --- a/_testimonials/tabbles-1.md +++ b/_testimonials/tabbles-1.md @@ -8,13 +8,11 @@ keywords: - business logic quote: '...the core logic is written in F# wherever possible...' --- -Yellow blue soft is a truly international Micro-ISV: We are a small, dynamic and international -team who is wondering why file-management is lagging 30 years behind and no one seems to care -or even notice. We do. We love what we're doing and most importantly we love listening to you! +Yellow blue soft is a truly international Micro-ISV: We are a small, dynamic and international +team who is wondering why file-management is lagging 30 years behind and no one seems to care +or even notice. We do. We love what we're doing and most importantly we love listening to you! Visit our blog to know more about us and join our forum to become part of our sparkling community. -The tabbles are special containers that you can use to categorize any kind of file and document as -well as folders and bookmarks. Using Tabbles you can quickly categorize, find, sort and share your +The tabbles are special containers that you can use to categorize any kind of file and document as +well as folders and bookmarks. Using Tabbles you can quickly categorize, find, sort and share your documents, in a totally new way. - - \ No newline at end of file diff --git a/_testimonials/uni-pisa-1.md b/_testimonials/uni-pisa-1.md index 688ed8e2..f280e5a4 100644 --- a/_testimonials/uni-pisa-1.md +++ b/_testimonials/uni-pisa-1.md @@ -6,24 +6,22 @@ bullets: keywords: [] quote: We recommend teaching F# because it is an extraordinary and flexible tool for teaching different areas of Computer Science --- -At the University of Pisa we use F# for teaching UI programming, a fundamental course in the third year curriculum. -In 2014 two more courses (Programming I & II) will use F# and Try F#. +At the University of Pisa we use F# for teaching UI programming, a fundamental course in the third year curriculum. +In 2014 two more courses (Programming I & II) will use F# and Try F#. -We use F# for teaching because it fits teaching both fundamentals and technology thanks to rich programming -environment and libraries to access all system resources (such as UIs). Moreover, F# feels like a dynamic -language thanks to F# interactive even if it is a statically typed language. Our students use F# on Windows, -Mac and Linux. Try F# is a particularly valuable tool for teaching because it has a quite sophisticated +We use F# for teaching because it fits teaching both fundamentals and technology thanks to rich programming +environment and libraries to access all system resources (such as UIs). Moreover, F# feels like a dynamic +language thanks to F# interactive even if it is a statically typed language. Our students use F# on Windows, +Mac and Linux. Try F# is a particularly valuable tool for teaching because it has a quite sophisticated editor with interactive evaluation and the ability of sharing saved files with students. -I’ve also used F# for teaching programming for scientists at Scuola Normale Superiore, a PhD -course at ITU Copenhagen and to graduate students in biomedical engineering. +I’ve also used F# for teaching programming for scientists at Scuola Normale Superiore, a PhD +course at ITU Copenhagen and to graduate students in biomedical engineering. -We recommend teaching F# because it is an extraordinary and flexible tool for teaching different areas of -Computer Science. The language is rich and its functional nature allows to easily define the appropriate -subset for teaching particular concepts. I use it to teach entire classes by typing code and evaluate interactively -discussing the results of a single evaluation. It is also a great tool for teaching programming to scientists -and engineers: I found that its mathematical roots in lambda calculus are more readily grasped by -non-programmers, and interactive evaluation recalls environments such as Matlab and Mathematica very +We recommend teaching F# because it is an extraordinary and flexible tool for teaching different areas of +Computer Science. The language is rich and its functional nature allows to easily define the appropriate +subset for teaching particular concepts. I use it to teach entire classes by typing code and evaluate interactively +discussing the results of a single evaluation. It is also a great tool for teaching programming to scientists +and engineers: I found that its mathematical roots in lambda calculus are more readily grasped by +non-programmers, and interactive evaluation recalls environments such as Matlab and Mathematica very popular in these communities. - - \ No newline at end of file diff --git a/_testimonials/vitor-pereira.md b/_testimonials/vitor-pereira.md index 2ec836db..84c9e014 100644 --- a/_testimonials/vitor-pereira.md +++ b/_testimonials/vitor-pereira.md @@ -17,8 +17,6 @@ Besides all the benefits of the functional paradigm for this type of work, F# in the .NET platform allows the construction of powerful implementations that other functional languages do not allow so easily. -I really hope that, in the future, I keep working in Cryptography using F# as the main programming -language for my projects. I am also preparing a hands-on presentation about F# and Cryptography to +I really hope that, in the future, I keep working in Cryptography using F# as the main programming +language for my projects. I am also preparing a hands-on presentation about F# and Cryptography to be presented at an event in Microsoft Portugal, which I will surely enjoy! - - \ No newline at end of file diff --git a/_testimonials/waisal-1.md b/_testimonials/waisal-1.md index dcda6f64..ab8bff45 100644 --- a/_testimonials/waisal-1.md +++ b/_testimonials/waisal-1.md @@ -11,4 +11,3 @@ keywords: quote: F# proved ideal for the complex data machinations required to build the models from raw Excel input. --- We developed a ClickOnce F# / WPF application that scores and ranks thousands of models of part-supplier combinations using Microsoft Solver Foundation (MSF). Agents can chose from the highest scoring combinations to optimize purchasing decisions. F# proved ideal for the complex data machinations required to build the models from raw Excel input. Also, the MSF supplied F# functional wrapper is a great way of using Solver Foundation from F#. - \ No newline at end of file diff --git a/_testimonials/yan-cui.md b/_testimonials/yan-cui.md index 96812375..c8c5646d 100644 --- a/_testimonials/yan-cui.md +++ b/_testimonials/yan-cui.md @@ -15,19 +15,17 @@ quote: The F# solution offers us an order of magnitude increase in productivty.. --- F# is becoming an increasingly important part of our server side infrastructure that supports our mobile and web-based social games with millions of active users. F# first came to prominence -in our technology stack in the implementation of the rules engine for our social slots games -which by now serve over **700,000 unique players** and **150,000,000 requests** per day at peaks +in our technology stack in the implementation of the rules engine for our social slots games +which by now serve over **700,000 unique players** and **150,000,000 requests** per day at peaks of several thousand requests per second. The F# solution offers us an **order of magnitude increase in productivity** and allows -one developer to perform the work that are performed by a team of dedicated developers on an -existing Java-based solution, and is critical in supporting our agile approach and bi-weekly +one developer to perform the work that are performed by a team of dedicated developers on an +existing Java-based solution, and is critical in supporting our agile approach and bi-weekly release cycles. -The [agent-based programming model](http://www.developerfusion.com/article/139804/an-introduction-to-f-agents/) +The [agent-based programming model](http://www.developerfusion.com/article/139804/an-introduction-to-f-agents/) offered by F#'s MailboxProcessor allows us to **build thread-safe components with high-concurrency requirements effortlessly**, without using locks and sacrificing maintainability and complexity. These agent-based solutions also offer much improved efficiency and latency whilst running at scale. Indeed our agent-based stateful server for our [MMORPG](https://apps.facebook.com/herebemonsters/) has proved a big success and great cost saver that we're in the process of rolling it out across all of our social games! - - \ No newline at end of file diff --git a/community/projects/index.md b/community/projects/index.md index 4a677812..4b7c64bf 100644 --- a/community/projects/index.md +++ b/community/projects/index.md @@ -18,29 +18,24 @@ Tags: Compiler, Editing, Financial, Desktop UI, Mobile, Math, Text Search, Metaprogramming, Literate programming, Audio Processing -

Community Projects: Other Catalogs

* [Awesome F#](https://github.com/fsprojects/awesome-fsharp) - A curated list of awesome F# frameworks, libraries, software and resources. * [FSharpest](https://www.fsharpest.xyz) - A directory to discover F# tools, libraries and resources. - -

Community Projects: Compiler and Core Library

-* logo [dotnet/fsharp](https://github.com/dotnet/fsharp) - The F# Compiler, F# Core Library and F# Compiler Service. +* logo [dotnet/fsharp](https://github.com/dotnet/fsharp) - The F# Compiler, F# Core Library and F# Compiler Service.

Community Projects: Editing Tools

-* ![logo](../../images/thumbs/ionide.png) [Ionide](http://ionide.io) - The VSCode plugin for F# development - -* ![logo](../../images/thumbs/vstudio.png) [Visual F# Tools](https://github.com/dotnet/fsharp) - The IDE tools for F# that are part of Visual Studio. Contributions welcome! +* ![logo](../../images/thumbs/ionide.png) [Ionide](http://ionide.io) - The VSCode plugin for F# development -* ![logo](../../images/thumbs/fsharpbinding.png) [FsAutoComplete](https://github.com/fsharp/FsAutoComplete) - F# command line tool run as background process to serve information for editor tools such as Emacs, Vim, Sublime Text, Atom and VS Code - -* ![logo](../../images/thumbs/fantomas.png) [Fantomas](https://github.com/fsprojects/fantomas) - F# source code formatter +* ![logo](../../images/thumbs/vstudio.png) [Visual F# Tools](https://github.com/dotnet/fsharp) - The IDE tools for F# that are part of Visual Studio. Contributions welcome! +* ![logo](../../images/thumbs/fsharpbinding.png) [FsAutoComplete](https://github.com/fsharp/FsAutoComplete) - F# command line tool run as background process to serve information for editor tools such as Emacs, Vim, Sublime Text, Atom and VS Code +* ![logo](../../images/thumbs/fantomas.png) [Fantomas](https://github.com/fsprojects/fantomas) - F# source code formatter

Community Projects: Literate Programming, Notebooks and Documentation

@@ -48,105 +43,96 @@ Tags: Compiler, Editing, Community Projects: Development Tools -* ![logo](../../images/thumbs/Paket.png) [Paket](https://fsprojects.github.io/Paket/) - A package dependency manager for .NET with support for NuGet packages and GitHub repositories +* ![logo](../../images/thumbs/Paket.png) [Paket](https://fsprojects.github.io/Paket/) - A package dependency manager for .NET with support for NuGet packages and GitHub repositories -* [F# Type Provider SDK](https://github.com/fsprojects/FSharp.TypeProviders.SDK) - Learning materials and code only NuGet package for writing type providers +* [F# Type Provider SDK](https://github.com/fsprojects/FSharp.TypeProviders.SDK) - Learning materials and code only NuGet package for writing type providers -* ![logo](../../images/thumbs/FAKE.png) [FAKE](https://fake.build) - F# build automation system - -* ![logo](../../images/thumbs/FSharpLint.png) [FSharpLint](https://fsprojects.github.io/FSharpLint/) - A lint tool for F#. - -* [F# SonarQube Plugin](https://github.com/jmecosta/sonar-fsharp-plugin) - F# support for SonarQube. +* ![logo](../../images/thumbs/FAKE.png) [FAKE](https://fake.build) - F# build automation system +* ![logo](../../images/thumbs/FSharpLint.png) [FSharpLint](https://fsprojects.github.io/FSharpLint/) - A lint tool for F#. +* [F# SonarQube Plugin](https://github.com/jmecosta/sonar-fsharp-plugin) - F# support for SonarQube.

Community Projects: Functional Programming

-* ![logo](../../images/thumbs/nessos.png) [Streams](http://nessos.github.io/Streams/) - A lightweight F#/C# library for efficient functional-style pipelines on streams of data. +* ![logo](../../images/thumbs/nessos.png) [Streams](http://nessos.github.io/Streams/) - A lightweight F#/C# library for efficient functional-style pipelines on streams of data. -* ![logo](../../images/thumbs/nessos.png) [LinqOptimizer](http://nessos.github.io/LinqOptimizer/) - An automatic query optimizer-compiler for Sequential and Parallel LINQ. LinqOptimizer compiles declarative LINQ queries into fast loop-based imperative code. The compiled code has fewer virtual calls and heap allocations, better data locality and speedups of up to 15x (Check the Performance page). +* ![logo](../../images/thumbs/nessos.png) [LinqOptimizer](http://nessos.github.io/LinqOptimizer/) - An automatic query optimizer-compiler for Sequential and Parallel LINQ. LinqOptimizer compiles declarative LINQ queries into fast loop-based imperative code. The compiled code has fewer virtual calls and heap allocations, better data locality and speedups of up to 15x (Check the Performance page). -* ![logo](../../images/thumbs/FSharpx.Collections.png) [FSharpx.Collections](http://fsprojects.github.io/FSharpx.Collections/) - A set of functional programming collections for F#. +* ![logo](../../images/thumbs/FSharpx.Collections.png) [FSharpx.Collections](http://fsprojects.github.io/FSharpx.Collections/) - A set of functional programming collections for F#. -* [Aether](https://github.com/xyncro/aether) - An optics (lenses, prisms, morphisms) library for F# that enables powerful ways of working with data structures. - -* [F# Snippets](http://fssnip.net/) - A community-contributed catalog of F# Snippets +* [Aether](https://github.com/xyncro/aether) - An optics (lenses, prisms, morphisms) library for F# that enables powerful ways of working with data structures. +* [F# Snippets](http://fssnip.net/) - A community-contributed catalog of F# Snippets

Community Projects: Text Programming

-* [FSharp.Text.RegexProvider](http://fsprojects.github.io/FSharp.Text.RegexProvider/) - A type provider for regular expressions. - +* [FSharp.Text.RegexProvider](http://fsprojects.github.io/FSharp.Text.RegexProvider/) - A type provider for regular expressions.

Community Projects: Data Access

-* ![logo](../../images/thumbs/FSharp.Data.png) [F# Data](http://fsprojects.github.io/FSharp.Data) - A library of F# type providers and data access tools. Contributions welcome! +* ![logo](../../images/thumbs/FSharp.Data.png) [F# Data](http://fsprojects.github.io/FSharp.Data) - A library of F# type providers and data access tools. Contributions welcome! - * [WorldBank Provider](http://fsprojects.github.io/FSharp.Data/library/WorldBank.html) - Makes the WorldBank data easily accessible to F# programs and scripts in a type safe way, which has a data catalog of over 8000 development indicators and other data about countries in the world. + * [WorldBank Provider](http://fsprojects.github.io/FSharp.Data/library/WorldBank.html) - Makes the WorldBank data easily accessible to F# programs and scripts in a type safe way, which has a data catalog of over 8000 development indicators and other data about countries in the world. - * [CSV Type Provider](http://fsprojects.github.io/FSharp.Data/library/CsvProvider.html) - Read CSV files in a statically typed way. + * [CSV Type Provider](http://fsprojects.github.io/FSharp.Data/library/CsvProvider.html) - Read CSV files in a statically typed way. - * [HTML Type Provider](http://fsprojects.github.io/FSharp.Data/library/HtmlProvider.html) - Work with tables and lists in HTML files in a statically typed way. + * [HTML Type Provider](http://fsprojects.github.io/FSharp.Data/library/HtmlProvider.html) - Work with tables and lists in HTML files in a statically typed way. - * [JSON Type Provider](http://fsprojects.github.io/FSharp.Data/library/JsonProvider.html) - Access JSON files in a statically typed way. + * [JSON Type Provider](http://fsprojects.github.io/FSharp.Data/library/JsonProvider.html) - Access JSON files in a statically typed way. - * [XML Type Provider](http://fsprojects.github.io/FSharp.Data/library/XmlProvider.html) - Access XML documents in a statically typed way. + * [XML Type Provider](http://fsprojects.github.io/FSharp.Data/library/XmlProvider.html) - Access XML documents in a statically typed way. -* ![logo](../../images/thumbs/FSharp.Data.Toolbox.png) [FSharp.Data.Toolbox](http://fsprojects.github.io/FSharp.Data.Toolbox) - F# Data-based library for various data access APIs, includes a Twitter access package. +* ![logo](../../images/thumbs/FSharp.Data.Toolbox.png) [FSharp.Data.Toolbox](http://fsprojects.github.io/FSharp.Data.Toolbox) - F# Data-based library for various data access APIs, includes a Twitter access package. -* [Chiron](https://github.com/xyncro/chiron) - A library for functional JSON in F#, including parsing, formatting, serialization and deserialization (through explicit object mapping), and working effectively with complex JSON data. +* [Chiron](https://github.com/xyncro/chiron) - A library for functional JSON in F#, including parsing, formatting, serialization and deserialization (through explicit object mapping), and working effectively with complex JSON data. -* ![logo](../../images/thumbs/FSharp.Data.SqlClient.png) [FSharp.Data.SqlClient](http://fsprojects.github.io/FSharp.Data.SqlClient/) - use SQL to specify queries, explore Stored Procedures, User Defined Types and Functions with auto-complete right in your F# code. +* ![logo](../../images/thumbs/FSharp.Data.SqlClient.png) [FSharp.Data.SqlClient](http://fsprojects.github.io/FSharp.Data.SqlClient/) - use SQL to specify queries, explore Stored Procedures, User Defined Types and Functions with auto-complete right in your F# code. -* [FSharp.Linq.ComposableQuery](http://fsprojects.github.io/FSharp.Linq.ComposableQuery/) - A Compositional Query Framework for F# Queries, based on "A Practical Theory of Language-Integrated Query" +* [FSharp.Linq.ComposableQuery](http://fsprojects.github.io/FSharp.Linq.ComposableQuery/) - A Compositional Query Framework for F# Queries, based on "A Practical Theory of Language-Integrated Query" -* [SQLProvider](http://fsprojects.github.io/SQLProvider/) - A general SQL type provider, supporting LINQ queries, schema exploration, stored procedures, individuals. Currently supports MS SQL Server, MS Access, SQLite, PostgreSQL, Oracle and MySQL. +* [SQLProvider](http://fsprojects.github.io/SQLProvider/) - A general SQL type provider, supporting LINQ queries, schema exploration, stored procedures, individuals. Currently supports MS SQL Server, MS Access, SQLite, PostgreSQL, Oracle and MySQL. -* [DynamicsNAVProvider](https://github.com/fsprojects/DynamicsNAVProvider) - A Microsoft Dynamics NAV type provider, supporting LINQ queries, schema exploration, individuals. +* [DynamicsNAVProvider](https://github.com/fsprojects/DynamicsNAVProvider) - A Microsoft Dynamics NAV type provider, supporting LINQ queries, schema exploration, individuals. -* [DynamicsCRMProvider](https://github.com/fsprojects/DynamicsCRMProvider) - A type provider for Microsoft Dynamics CRM 2011/2013. +* [DynamicsCRMProvider](https://github.com/fsprojects/DynamicsCRMProvider) - A type provider for Microsoft Dynamics CRM 2011/2013. -* ![logo](../../images/thumbs/S3Provider.png) [S3 Type Provider](http://fsprojects.github.io/S3Provider/) - An experimental type provider for Amazon S3. +* ![logo](../../images/thumbs/S3Provider.png) [S3 Type Provider](http://fsprojects.github.io/S3Provider/) - An experimental type provider for Amazon S3. -* [Azure Storage Type Provider](http://fsprojects.github.io/AzureStorageTypeProvider/) - A type provider for Azure Storage assets e.g. Blobs and Tables. +* [Azure Storage Type Provider](http://fsprojects.github.io/AzureStorageTypeProvider/) - A type provider for Azure Storage assets e.g. Blobs and Tables. -* ![logo](../../images/thumbs/DAXIFsharp.png) [DAXIF# - Delegate Automated Xrm Installation Framework](https://github.com/delegateas/Daxif) - A set of tools that in combination with other Microsoft Tools, make it easier to work with Microsoft Dynamics CRM/xRM on a daily basis, also for developers who are not familiar with the platform. +* ![logo](../../images/thumbs/DAXIFsharp.png) [DAXIF# - Delegate Automated Xrm Installation Framework](https://github.com/delegateas/Daxif) - A set of tools that in combination with other Microsoft Tools, make it easier to work with Microsoft Dynamics CRM/xRM on a daily basis, also for developers who are not familiar with the platform. * ![logo](../../images/thumbs/sqlfun-small.png) [SqlFun](https://jacentino.github.io/SqlFun) - An SQL database access library. Supports direct SQL calls, automatic CRUD operations, stored procedures, collection parameters and complex result structures. Allows to define custom query DSL-s. Type safe and idiomatically functional. * [Donald](https://github.com/pimbrouwers/Donald) - An idiomatic F# interface for ADO.NET. - -

Community Projects: Data Science Programming

-* [FsLab](http://fslab.org) - FsLab is a collection of libraries for data-science. It provides a rapid development envi­ronment that lets you write advanced analysis with few lines of production-quality code. +* [FsLab](http://fslab.org) - FsLab is a collection of libraries for data-science. It provides a rapid development envi­ronment that lets you write advanced analysis with few lines of production-quality code. -* ![logo](../../images/thumbs/Deedle.png) [Deedle](http://fslab.org/Deedle/) - Deedle is an open, easy to use library for data +* ![logo](../../images/thumbs/Deedle.png) [Deedle](http://fslab.org/Deedle/) - Deedle is an open, easy to use library for data and time series manipulation and for scientific programming. It supports working with structured data frames, ordered and unordered data, as well as time series. Deedle is designed to work well for exploratory programming using F# and C# interactive console, but can be also used in efficient compiled .NET code. -* [The MATLAB Type Provider for F#](http://bayardrock.github.io/Matlab-Type-Provider/) - An F# type provider +* [The MATLAB Type Provider for F#](http://bayardrock.github.io/Matlab-Type-Provider/) - An F# type provider for higher-fidelity integration between F# and MATLAB. Early stages. Contributors and reviewers welcome. -* [The Python Type Provider for F# (experimental)](http://fsprojects.github.io/FSharp.Interop.PythonProvider/) - Python type provider for F#. - -* [Vulpes](https://github.com/SpiegelSoft/Vulpes) - A machine learning app using a deep belief network and connecting to the NVIDIA GPU unit using [Alea.cuBase] (http://blog.quantalea.net/). +* [The Python Type Provider for F# (experimental)](http://fsprojects.github.io/FSharp.Interop.PythonProvider/) - Python type provider for F#. +* [Vulpes](https://github.com/SpiegelSoft/Vulpes) - A machine learning app using a deep belief network and connecting to the NVIDIA GPU unit using [Alea.cuBase] ().

Community Projects: Visualization Tools

-* ![logo](../../images/thumbs/XPlot.png)[XPlot](http://fslab.org/XPlot/) - XPlot is a data visualization package for the F# programming language powered by popular JavaScript charting libraries. +* ![logo](../../images/thumbs/XPlot.png)[XPlot](http://fslab.org/XPlot/) - XPlot is a data visualization package for the F# programming language powered by popular JavaScript charting libraries. It uses Google and Plotly's powerful and free data visualization libraries based on HTML5/SVG technology. You can access the HTML for the charts programatically and use the library from F# Interactive by displaying browser windows. @@ -154,61 +140,57 @@ Tags: Compiler, Editing, Community Projects: Math Libraries -* ![logo](../../images/thumbs/MathNet.png) [Math.NET Numerics](http://numerics.mathdotnet.com/) - A large collection of +* ![logo](../../images/thumbs/MathNet.png) [Math.NET Numerics](http://numerics.mathdotnet.com/) - A large collection of algorithms including linear algebra, special functions, statistics, probability models, interpolation and FFTs. Supports F# 3.0+ with idiomatic extension modules. -* ![logo](../../images/thumbs/DiffSharpLogoSmall.png) [DiffSharp](http://diffsharp.github.io/DiffSharp/) - An automatic differentiation (AD) library for exact and efficient calculation of derivatives (gradients, Hessians, Jacobians, directional derivatives, and matrix-free Hessian- and Jacobian-vector products). Also includes symbolic and numerical differentiation. -* ![logo](../../images/thumbs/FsAlgLogoSmall.png) [FsAlg](http://gbaydin.github.io/FsAlg/) - A lightweight linear algebra library supporting generic types. +* ![logo](../../images/thumbs/DiffSharpLogoSmall.png) [DiffSharp](http://diffsharp.github.io/DiffSharp/) - An automatic differentiation (AD) library for exact and efficient calculation of derivatives (gradients, Hessians, Jacobians, directional derivatives, and matrix-free Hessian- and Jacobian-vector products). Also includes symbolic and numerical differentiation. +* ![logo](../../images/thumbs/FsAlgLogoSmall.png) [FsAlg](http://gbaydin.github.io/FsAlg/) - A lightweight linear algebra library supporting generic types. * [Flips](https://flipslibrary.com/) - An F# library for modeling and solving Linear Programming (LP) and Mixed-Integer Programming (MIP) problems. -

Community Projects: Mobile Programming

-* [Fabulous](https://fabulous.dev) - Allows you to use the Elm architecture (Redux/Flow/MVU), to build Xamarin.Forms applications for iOS, Android, Mac and more +* [Fabulous](https://fabulous.dev) - Allows you to use the Elm architecture (Redux/Flow/MVU), to build Xamarin.Forms applications for iOS, Android, Mac and more -* [Fable + React Native](https://github.com/fable-compiler/fable-react-native/) - Allows you to use Fable + React Native to write mobile applications +* [Fable + React Native](https://github.com/fable-compiler/fable-react-native/) - Allows you to use Fable + React Native to write mobile applications

Community Projects: Client User Interfaces

-* [Interstellar](https://fsprojects.github.io/Interstellar/) - A library that enables the creation of cross-platform browser-based applications. It abstracts around various different browser APIs, so your application can use either Chromium or Apple WebKit. +* [Interstellar](https://fsprojects.github.io/Interstellar/) - A library that enables the creation of cross-platform browser-based applications. It abstracts around various different browser APIs, so your application can use either Chromium or Apple WebKit. -* [FsXaml](https://github.com/fsprojects/FsXaml) - F# Tools for working with XAML Projects - -* [FSharp.ViewModule](https://github.com/fsprojects/FSharp.ViewModule/) - Type provider to generate an MVVM style ViewModel directly from an idiomatic F# module. +* [FsXaml](https://github.com/fsprojects/FsXaml) - F# Tools for working with XAML Projects +* [FSharp.ViewModule](https://github.com/fsprojects/FSharp.ViewModule/) - Type provider to generate an MVVM style ViewModel directly from an idiomatic F# module.

Community Projects: Financial Calculations and Data

-* ![logo](../../images/thumbs/ExcelFinancialFunctions.png) [ExcelFinancialFunctions](http://fsprojects.github.io/ExcelFinancialFunctions/) - Excel Financial functions, implemented in F#, with a high degree of conformance testing. - -* [Spreads](https://github.com/Spreads/Spreads/#spreads) - Spreads is an ultra-fast library for complex event processing and time series manipulation. Spreads is a library, not a framework, and could be plugged into existing code bases and used immediately. Even though the primary domain is financial data, Spreads is designed as a generic complex event processing library. +* ![logo](../../images/thumbs/ExcelFinancialFunctions.png) [ExcelFinancialFunctions](http://fsprojects.github.io/ExcelFinancialFunctions/) - Excel Financial functions, implemented in F#, with a high degree of conformance testing. +* [Spreads](https://github.com/Spreads/Spreads/#spreads) - Spreads is an ultra-fast library for complex event processing and time series manipulation. Spreads is a library, not a framework, and could be plugged into existing code bases and used immediately. Even though the primary domain is financial data, Spreads is designed as a generic complex event processing library.

Community Projects: Web Tools

-* ![logo](../../images/thumbs/suave.png) [Suave](http://suave.io) - Suave is a simple web development F# library providing a lightweight web server and a set of combinators to manipulate route flow and task composition. +* ![logo](../../images/thumbs/suave.png) [Suave](http://suave.io) - Suave is a simple web development F# library providing a lightweight web server and a set of combinators to manipulate route flow and task composition. -* ![logo](../../images/thumbs/WebSharper.png) [WebSharper](http://websharper.com) - WebSharper is an F#-based web programming platform +* ![logo](../../images/thumbs/WebSharper.png) [WebSharper](http://websharper.com) - WebSharper is an F#-based web programming platform including a compiler from F# code to JavaScript. Primary contributors are IntelliFactory, it is open source and on GitHub. Contributors welcome! -* ![logo](../../images/thumbs/fable.png) [Fable](https://fable.io) is an F# to JS compiler designed to generate clean +* ![logo](../../images/thumbs/fable.png) [Fable](https://fable.io) is an F# to JS compiler designed to generate clean and standard code in order to maximize interoperability in both ways. It integrates with most of JS development pipelines like [Babel](http://babeljs.io), [Webpack](https://webpack.github.io) or [React Hot Loader](http://gaearon.github.io/react-hot-loader/). Fable allows you develop not only web apps but also [node.js](https://nodejs.org/en/), desktop with [Electron](http://electron.atom.io) or mobile with [React native](https://facebook.github.io/react-native/). -* ![logo](../../images/thumbs/fracture.png) [Fracture I/O](https://github.com/fractureio/fracture) - High performance sockets library. +* ![logo](../../images/thumbs/fracture.png) [Fracture I/O](https://github.com/fractureio/fracture) - High performance sockets library. -* ![logo](../../images/thumbs/fracture.png) [Fracture.Http](https://github.com/fractureio/fracture.http) - HTTP server built on Fracture I/O. +* ![logo](../../images/thumbs/fracture.png) [Fracture.Http](https://github.com/fractureio/fracture.http) - HTTP server built on Fracture I/O. -* [Frank](https://github.com/frank-fs/frank) - Frank provides a functional wrapper around the types in System.Net.Http, the library used by ASP.NET Web API. +* [Frank](https://github.com/frank-fs/frank) - Frank provides a functional wrapper around the types in System.Net.Http, the library used by ASP.NET Web API. -* [Freya](https://github.com/freya-fs/freya) - F# support for [OWIN](http://owin.org/). Freya is a functional web stack, built on top of OWIN, that offers additional layers for constructing OWIN pipelines, types based on relevant RFC definitions, a router, and an [HTTP finite state machine](https://github.com/for-GET/http-decision-diagram) abstraction similar to that found in [webmachine](https://github.com/basho/webmachine). +* [Freya](https://github.com/freya-fs/freya) - F# support for [OWIN](http://owin.org/). Freya is a functional web stack, built on top of OWIN, that offers additional layers for constructing OWIN pipelines, types based on relevant RFC definitions, a router, and an [HTTP finite state machine](https://github.com/for-GET/http-decision-diagram) abstraction similar to that found in [webmachine](https://github.com/basho/webmachine). * [FsBlog](https://github.com/fsprojects/FsBlog/) - A blog aware, static site generation using F#. Inpired by the likes of Jekyll and Octopress. @@ -218,135 +200,126 @@ Tags: Compiler, Editing, Community Projects: Scripting & Configuration +* ![logo](../../images/thumbs/FSharp.Management.png) [FSharp.Management](http://fsprojects.github.io/FSharp.Management/index.html) - The FSharp.Management project contains various type providers for the management of the machine. -* ![logo](../../images/thumbs/FSharp.Management.png) [FSharp.Management](http://fsprojects.github.io/FSharp.Management/index.html) - The FSharp.Management project contains various type providers for the management of the machine. - - * [PowerShellTypeProvider](http://fsprojects.github.io/FSharp.Management/PowerShellProvider.html) - PowerShell type provider. - - * [FileSystemTypeProvider](http://fsprojects.github.io/FSharp.Management/FileSystemProvider.html) - It allows to browse your file system via autocomplete and provides compile time checks for directories and files. + * [PowerShellTypeProvider](http://fsprojects.github.io/FSharp.Management/PowerShellProvider.html) - PowerShell type provider. - * [WMITypeProvider](http://fsprojects.github.io/FSharp.Management/WMIProvider.html) - Typed access to WMI. + * [FileSystemTypeProvider](http://fsprojects.github.io/FSharp.Management/FileSystemProvider.html) - It allows to browse your file system via autocomplete and provides compile time checks for directories and files. - * [RegistryTypeProvider](http://fsprojects.github.io/FSharp.Management/RegistryProvider.html) - Typed access to the Registry. + * [WMITypeProvider](http://fsprojects.github.io/FSharp.Management/WMIProvider.html) - Typed access to WMI. + * [RegistryTypeProvider](http://fsprojects.github.io/FSharp.Management/RegistryProvider.html) - Typed access to the Registry. -* ![logo](../../images/thumbs/FSharp.Configuration.png) [FSharp.Configuration](http://fsprojects.github.io/FSharp.Configuration/index.html) - The FSharp.Configuration project contains type providers for the configuration of .NET projects. +* ![logo](../../images/thumbs/FSharp.Configuration.png) [FSharp.Configuration](http://fsprojects.github.io/FSharp.Configuration/index.html) - The FSharp.Configuration project contains type providers for the configuration of .NET projects. - * [AppSettingsTypeProvider](http://fsprojects.github.io/FSharp.Configuration/AppSettingsProvider.html) - AppSettings type provider. + * [AppSettingsTypeProvider](http://fsprojects.github.io/FSharp.Configuration/AppSettingsProvider.html) - AppSettings type provider. - * [ResXTypeProvider](http://fsprojects.github.io/FSharp.Configuration/ResXProvider.html) - Typed access to .resx files. + * [ResXTypeProvider](http://fsprojects.github.io/FSharp.Configuration/ResXProvider.html) - Typed access to .resx files. - * [YamlConfigProvider](https://fsprojects.github.io/FSharp.Configuration/YamlConfigProvider.html) - Typed access to Yaml. - - -* [Stellar](https://github.com/panesofglass/stellar) - Typed access to the Windows Azure Management REST APIs. + * [YamlConfigProvider](https://fsprojects.github.io/FSharp.Configuration/YamlConfigProvider.html) - Typed access to Yaml. +* [Stellar](https://github.com/panesofglass/stellar) - Typed access to the Windows Azure Management REST APIs.

Community Projects: Asynchronous, Concurrent and Parallel Programming

-* ![logo](../../images/thumbs/PSeq.png) [F# Parallel Sequences](http://fsprojects.github.io/FSharp.Collections.ParallelSeq/). This component provides F#-style API for parallel operations on sequences that are part of .NET 4.0 as System.Linq.ParallelEnumerable class. The API is akin to F# operations on sequences. - -* ![logo](../../images/thumbs/FSharp.Control.Reactive.png) [FSharp.Control.Reactive](http://fsprojects.github.io/FSharp.Control.Reactive/). F#-style modules for working with the Reactive Extensions (Rx) as a set of extensions to the built-in Observable module. The library includes observe and rxquery computation expressions, as well. +* ![logo](../../images/thumbs/PSeq.png) [F# Parallel Sequences](http://fsprojects.github.io/FSharp.Collections.ParallelSeq/). This component provides F#-style API for parallel operations on sequences that are part of .NET 4.0 as System.Linq.ParallelEnumerable class. The API is akin to F# operations on sequences. -* [Cricket](https://github.com/fsprojects/Cricket). Cricket is an actor library for F#. The actor programming model is inherently concurrent, an actor is a primitive that wraps a computation, the computation is ran by sending messages to the actor. The actor can then respond to the reciept of the message by executing one or more of the following actions (possibly concurrently). +* ![logo](../../images/thumbs/FSharp.Control.Reactive.png) [FSharp.Control.Reactive](http://fsprojects.github.io/FSharp.Control.Reactive/). F#-style modules for working with the Reactive Extensions (Rx) as a set of extensions to the built-in Observable module. The library includes observe and rxquery computation expressions, as well. -* ![logo](../../images/thumbs/FSharp.Control.FusionTasks.png) [FusionTasks](https://github.com/kekyo/FSharp.Control.FusionTasks/). F# Async workflow <--> .NET Task easy seamless interoperability library. +* [Cricket](https://github.com/fsprojects/Cricket). Cricket is an actor library for F#. The actor programming model is inherently concurrent, an actor is a primitive that wraps a computation, the computation is ran by sending messages to the actor. The actor can then respond to the reciept of the message by executing one or more of the following actions (possibly concurrently). +* ![logo](../../images/thumbs/FSharp.Control.FusionTasks.png) [FusionTasks](https://github.com/kekyo/FSharp.Control.FusionTasks/). F# Async workflow <--> .NET Task easy seamless interoperability library.

Community Projects: Distribution Tools

-* [f0](https://github.com/joshcough/f0) - A binary [de]serialization combinator library, with binary-format +* [f0](https://github.com/joshcough/f0) - A binary [de]serialization combinator library, with binary-format phantom types and a compatible Scala partner implementation. -* ![logo](../../images/thumbs/nessos.png) [FsPickler](http://mbraceproject.github.io/FsPickler/) - A fast, general-purpose binary serializer for +* ![logo](../../images/thumbs/nessos.png) [FsPickler](http://mbraceproject.github.io/FsPickler/) - A fast, general-purpose binary serializer for .NET written in F# that doubles as a pickler combinator library. -* ![logo](../../images/thumbs/nessos.png) [Vagabond](http://mbraceproject.github.io/Vagabond/) - A library for distributing dynamic assemblies. +* ![logo](../../images/thumbs/nessos.png) [Vagabond](http://mbraceproject.github.io/Vagabond/) - A library for distributing dynamic assemblies. -* ![logo](../../images/thumbs/AkkaDotNET.png) [Akka.NET](https://github.com/akkadotnet/akka.net) - .NET community port of the Java/Scala framework Akka. +* ![logo](../../images/thumbs/AkkaDotNET.png) [Akka.NET](https://github.com/akkadotnet/akka.net) - .NET community port of the Java/Scala framework Akka. -* ![logo](../../images/thumbs/fszmq_logo.png) [fszmq](http://zeromq.github.io/fszmq/) - a binding to the ZeroMQ distributed computing library for F# (and other CLR languages). - -* ![logo](https://raw.githubusercontent.com/buybackoff/Ractor.CLR/master/docs/files/img/logo32.png) [Ractor.CLR](https://github.com/buybackoff/Ractor.CLR) - Redis based distributed actors system. +* ![logo](../../images/thumbs/fszmq_logo.png) [fszmq](http://zeromq.github.io/fszmq/) - a binding to the ZeroMQ distributed computing library for F# (and other CLR languages). +* ![logo](https://raw.githubusercontent.com/buybackoff/Ractor.CLR/master/docs/files/img/logo32.png) [Ractor.CLR](https://github.com/buybackoff/Ractor.CLR) - Redis based distributed actors system.

Community Projects: Cloud Tools

-* ![logo](../../images/thumbs/swf_ext.png) [Amazon.SimpleWorkflow.Extensions](http://fsprojects.github.io/Amazon.SimpleWorkflow.Extensions/) Extension to Amazon SDK's SimpleWorkflow capabilities to make it more intuitive to use +* ![logo](../../images/thumbs/swf_ext.png) [Amazon.SimpleWorkflow.Extensions](http://fsprojects.github.io/Amazon.SimpleWorkflow.Extensions/) Extension to Amazon SDK's SimpleWorkflow capabilities to make it more intuitive to use -* ![logo](../../images/thumbs/dynamodb_sql.png) [DynamoDB.SQL](http://fsprojects.github.io/DynamoDb.SQL/) SQL-like external DSL for querying and scanning Amazon DynamoDB +* ![logo](../../images/thumbs/dynamodb_sql.png) [DynamoDB.SQL](http://fsprojects.github.io/DynamoDb.SQL/) SQL-like external DSL for querying and scanning Amazon DynamoDB -* [Fog](http://dmohl.github.io/Fog/) - Fog brings the cloud down to earth and wraps it in something more easily used by F#. It provides a more functional approach to creating Windows Azure apps with F#. +* [Fog](http://dmohl.github.io/Fog/) - Fog brings the cloud down to earth and wraps it in something more easily used by F#. It provides a more functional approach to creating Windows Azure apps with F#. -* ![logo](../../images/thumbs/FSharp.Azure.png) [FSharp.Azure](https://github.com/daniel-chambers/FSharp.Azure) - FSharp.Azure provides an idiomatic F# API to query and modify data in Azure table storage using immutable F# record types. +* ![logo](../../images/thumbs/FSharp.Azure.png) [FSharp.Azure](https://github.com/daniel-chambers/FSharp.Azure) - FSharp.Azure provides an idiomatic F# API to query and modify data in Azure table storage using immutable F# record types. -* ![logo](../../images/thumbs/S3Provider.png) [S3 Type Provider](http://fsprojects.github.io/S3Provider/) - An experimental type provider for Amazon S3. +* ![logo](../../images/thumbs/S3Provider.png) [S3 Type Provider](http://fsprojects.github.io/S3Provider/) - An experimental type provider for Amazon S3. -* [Azure Storage Type Provider](http://fsprojects.github.io/AzureStorageTypeProvider/) - A type provider for Azure Storage assets e.g. Blobs and Tables. +* [Azure Storage Type Provider](http://fsprojects.github.io/AzureStorageTypeProvider/) - A type provider for Azure Storage assets e.g. Blobs and Tables. -* [FsDecider](https://github.com/glenbraun/FsDecider) F# computation expression builder for AWS Simple Workflow deciders. +* [FsDecider](https://github.com/glenbraun/FsDecider) F# computation expression builder for AWS Simple Workflow deciders.

Community Projects: Testing Tools

-* ![logo](../../images/thumbs/FSharpTest.png) [FSharpTest](http://visualstudiogallery.msdn.microsoft.com/a52388eb-e1d3-4900-a25a-d18c8d23a1f3) - NUnit Visual Studio Project template with sample failing tests in FsUnit, FsCheck, and Unquote. +* ![logo](../../images/thumbs/FSharpTest.png) [FSharpTest](http://visualstudiogallery.msdn.microsoft.com/a52388eb-e1d3-4900-a25a-d18c8d23a1f3) - NUnit Visual Studio Project template with sample failing tests in FsUnit, FsCheck, and Unquote. -* [FsUnit](http://fsprojects.github.io/FsUnit/) - Add F# functional syntax to NUnit, xUnit, and MsTest. +* [FsUnit](http://fsprojects.github.io/FsUnit/) - Add F# functional syntax to NUnit, xUnit, and MsTest. -* [FsCheck](https://fscheck.github.io/FsCheck/) - Random testing generator combinators, port of Haskell's QuickCheck. +* [FsCheck](https://fscheck.github.io/FsCheck/) - Random testing generator combinators, port of Haskell's QuickCheck. -* ![logo](../../images/thumbs/Foq.png) [Foq](https://github.com/fsprojects/Foq/) - A lightweight thread-safe mocking library for F#, C# & VB.Net. Use Foq to mock abstract classes and interfaces. +* ![logo](../../images/thumbs/Foq.png) [Foq](https://github.com/fsprojects/Foq/) - A lightweight thread-safe mocking library for F#, C# & VB.Net. Use Foq to mock abstract classes and interfaces. -* [AutoFixture.AutoFoq](http://www.nuget.org/packages/AutoFixture.AutoFoq) - A library which turns [AutoFixture](http://www.nuget.org/packages/AutoFixture) into an [Auto-mocking Container](http://blog.ploeh.dk/2013/03/11/auto-mocking-container/) where the mock instances are created by [Foq](https://github.com/fsprojects/Foq). +* [AutoFixture.AutoFoq](http://www.nuget.org/packages/AutoFixture.AutoFoq) - A library which turns [AutoFixture](http://www.nuget.org/packages/AutoFixture) into an [Auto-mocking Container](http://blog.ploeh.dk/2013/03/11/auto-mocking-container/) where the mock instances are created by [Foq](https://github.com/fsprojects/Foq). -* ![logo](../../images/thumbs/Unquote.png) [Unquote](http://www.swensensoftware.com/unquote/) - F# unit test assertions as quoted expressions and step-by-step failure messages. +* ![logo](../../images/thumbs/Unquote.png) [Unquote](http://www.swensensoftware.com/unquote/) - F# unit test assertions as quoted expressions and step-by-step failure messages. -* ![logo](../../images/thumbs/canopy.jpg) [canopy](http://lefthandedgoat.github.io/canopy/) - F#rictionless web testing with Selenium. +* ![logo](../../images/thumbs/canopy.jpg) [canopy](http://lefthandedgoat.github.io/canopy/) - F#rictionless web testing with Selenium. -* [TickSpec](https://github.com/fsprojects/TickSpec/) A lightweight F# Behaviour Driven Development (BDD) framework +* [TickSpec](https://github.com/fsprojects/TickSpec/) A lightweight F# Behaviour Driven Development (BDD) framework -* ![logo](../../images/thumbs/Fspec.png) [FSpec](https://github.com/PeteProgrammer/fspec) A context/specification testing framework for F# +* ![logo](../../images/thumbs/Fspec.png) [FSpec](https://github.com/PeteProgrammer/fspec) A context/specification testing framework for F# -* ![logo](../../images/thumbs/AntaniXml.png) [AntaniXml](http://giacomociti.github.io/AntaniXml/) Random generator of XML from XSD, based on FsCheck +* ![logo](../../images/thumbs/AntaniXml.png) [AntaniXml](http://giacomociti.github.io/AntaniXml/) Random generator of XML from XSD, based on FsCheck

Community Projects: Metaprogramming

-* ![logo](../../images/thumbs/Unquote.png) [Unquote](http://www.swensensoftware.com/unquote/) - Includes a fast quotations evaluator - -* ![logo](../../images/thumbs/FSharp.Quotations.Evaluator.png) [FSharp.Quotations.Evaluator](http://fsprojects.github.io/FSharp.Quotations.Evaluator/) - An evaluator for F# quotations +* ![logo](../../images/thumbs/Unquote.png) [Unquote](http://www.swensensoftware.com/unquote/) - Includes a fast quotations evaluator +* ![logo](../../images/thumbs/FSharp.Quotations.Evaluator.png) [FSharp.Quotations.Evaluator](http://fsprojects.github.io/FSharp.Quotations.Evaluator/) - An evaluator for F# quotations

Community Projects: Parsing and Compiler Tools

-* ![logo](../../images/thumbs/FsLexYacc.png) [FsLex and FsYacc](http://fsprojects.github.io/FsLexYacc/) FsLex and FsYacc implementations for F#. Contributions welcome. +* ![logo](../../images/thumbs/FsLexYacc.png) [FsLex and FsYacc](http://fsprojects.github.io/FsLexYacc/) FsLex and FsYacc implementations for F#. Contributions welcome. -* [FParsec](http://www.quanttec.com/fparsec/) A parser combinator library for F# +* [FParsec](http://www.quanttec.com/fparsec/) A parser combinator library for F# -* [ParsecClone](https://github.com/devshorts/ParsecClone) A fparsec subset clone that works on generalized stream classes +* [ParsecClone](https://github.com/devshorts/ParsecClone) A fparsec subset clone that works on generalized stream classes -* ![logo](../../images/thumbs/YaccConstructor.jpg) [YaccConstructor](https://github.com/YaccConstructor/YaccConstructor) Platform for grammarware research and development +* ![logo](../../images/thumbs/YaccConstructor.jpg) [YaccConstructor](https://github.com/YaccConstructor/YaccConstructor) Platform for grammarware research and development -* ![logo](https://github.com/fsprojects/YC.PrettyPrinter/raw/master/docs/files/img/logo32.png) [YC.PrettyPrinter](https://github.com/fsprojects/YC.PrettyPrinter) Printer combinators library +* ![logo](https://github.com/fsprojects/YC.PrettyPrinter/raw/master/docs/files/img/logo32.png) [YC.PrettyPrinter](https://github.com/fsprojects/YC.PrettyPrinter) Printer combinators library -* [LLVM-FS](https://github.com/fsprojects/llvm-fs) - LLVM bindings for F# +* [LLVM-FS](https://github.com/fsprojects/llvm-fs) - LLVM bindings for F# * ![Farkle's logo](../../images/thumbs/Farkle.png) [Farkle](https://teo-tsirpanis.github.io/Farkle/) - LALR parsing with combinator-like objects for F# and C#.

Community Projects: Text Search Tools

-* ![logo](../../images/thumbs/FlexSearch.png) [FlexSearch](https://github.com/FlexSearch/FlexSearch) Flexible and fast open source F# based Search Engine +* ![logo](../../images/thumbs/FlexSearch.png) [FlexSearch](https://github.com/FlexSearch/FlexSearch) Flexible and fast open source F# based Search Engine * [MITIE-Dot-Net](https://github.com/BayardRock/MITIE-Dot-Net/blob/master/README.md) - A Nice .NET Wrapper for the MITIE Information Extraction Library (Written in F#, but fully C# compatible) -

Community Projects: Simulation Tools

-* [Aivika for .NET](https://github.com/dsorokin/aivika-fsharp-ce) - A simulation library for discrete event simulation, system dynamics and agent-based modeling. +* [Aivika for .NET](https://github.com/dsorokin/aivika-fsharp-ce) - A simulation library for discrete event simulation, system dynamics and agent-based modeling. * [F# RISC-V Instruction Set formal specification](https://github.com/mrLSD/riscv-fs) - RISC-V CPU formal ISA Specification. RISC-V CPU simulator with ELF files execution and CLI support. [MIT]

Community Projects: Audio Processing

-* [FSound](https://github.com/albertp007/FSound) - A sound processing library written in F# +* [FSound](https://github.com/albertp007/FSound) - A sound processing library written in F# diff --git a/docs/index.md b/docs/index.md index f58cc2dc..97c1ad9e 100644 --- a/docs/index.md +++ b/docs/index.md @@ -12,11 +12,11 @@ Comprehensive F# documentation that includes general information about F#, a lan The reference documentation for the FSharp.Core library. -## [The F# Language Specification](../specs/language-spec) +## [The F# Language Specification](../specs/language-spec) -The specification gives an in-depth -technical explanation of the F# language constructs and required compiler behavior. -It discusses topics such as lexical analysis, grammar, types including type inference +The specification gives an in-depth +technical explanation of the F# language constructs and required compiler behavior. +It discusses topics such as lexical analysis, grammar, types including type inference algorithm, expressions, patterns and other. ## [F# Cheat Sheet](https://github.com/fsprojects/fsharp-cheatsheet) @@ -27,7 +27,7 @@ The cheat sheet is a small and concise guide to F# syntax for newcomers to get s ## [The F# Component Design Guidelines](https://docs.microsoft.com/dotnet/fsharp/style-guide/component-design-guidelines) -This document is a set of component -design guidelines for F# programming. It describes guidelines for designing libraries -for use from other languages, guidelines for F#-to-F# libraries and suggestions on +This document is a set of component +design guidelines for F# programming. It describes guidelines for designing libraries +for use from other languages, guidelines for F#-to-F# libraries and suggestions on coding conventions. diff --git a/guides/cloud/index.md b/guides/cloud/index.md index 7521c00c..546a41e5 100644 --- a/guides/cloud/index.md +++ b/guides/cloud/index.md @@ -26,6 +26,7 @@ For cloud-hosted web programming and services, refer to the [Web Programming Gui ### Integrated Stacks #### SAFE Stack + {: #safe-stack .anchor } ![logo](../../images/thumbs/safestack.png) [SAFE Stack](https://safe-stack.github.io/) is an end-to-end, functional-first stack for cloud-ready web development that @@ -44,7 +45,7 @@ coherent stack for type-safe, flexible, web-enabled applications that can be wri [Microsoft Azure](https://azure.microsoft.com/) provides access to Microsoft's worldwide datacenters through services including virtual machines, geo-redundant storage, database clusters, website deployment and other services. - * [Using F# on Azure](https://docs.microsoft.com/dotnet/articles/fsharp/using-fsharp-on-azure/) - Microsoft's comprehensive guide to using F# on Azure. +* [Using F# on Azure](https://docs.microsoft.com/dotnet/articles/fsharp/using-fsharp-on-azure/) - Microsoft's comprehensive guide to using F# on Azure. #### [Amazon Web Services](http://aws.amazon.com) @@ -54,7 +55,7 @@ hosting services. Amazon offers a .NET SDK for managing the AWS services, storage, compute instances, and other Amazon services. Some additional resources for using F# and .NET on Amazon's AWS service: - * [FSharp.AWS.DynamoDB](https://github.com/fsprojects/FSharp.AWS.DynamoDB#fsharpawsdynamodb) - an F# wrapper over the standard Amazon.DynamoDB library which allows you to represent table items using F# records and perform updates, queries and scans using F# quotation expressions +* [FSharp.AWS.DynamoDB](https://github.com/fsprojects/FSharp.AWS.DynamoDB#fsharpawsdynamodb) - an F# wrapper over the standard Amazon.DynamoDB library which allows you to represent table items using F# records and perform updates, queries and scans using F# quotation expressions ### Scalable Data Programming diff --git a/guides/data-access/index.md b/guides/data-access/index.md index 07517b9a..23b931c0 100644 --- a/guides/data-access/index.md +++ b/guides/data-access/index.md @@ -25,6 +25,7 @@ If the data access libraries you need are not listed here, you can search for th A wide range of high-quality libraries exist for SQL data access from F#. Many can be found on [NuGET](http://nuget.org). Some resources are listed below: + * [LINQ to DB](https://github.com/linq2db/linq2db) - LINQ to DB is the fastest LINQ database access library offering a simple, light, fast, and type-safe layer between your POCO objects and your database. * [FSharp.Data.SQLProvider](http://fsprojects.github.io/SQLProvider/) - A general SQL database type provider, supporting LINQ queries, schema exploration, individuals. Requires SQL Server, SQLite, PostgreSQL, Oracle, MySQL or Microsoft Access. diff --git a/guides/data-science/index.md b/guides/data-science/index.md index 42aac87a..724cd2c7 100644 --- a/guides/data-science/index.md +++ b/guides/data-science/index.md @@ -1,209 +1,213 @@ ---- -layout: default -title: Guide - Data Science | fsharp.org -headline: Guide - Data Science with F# -redirect_from: - - /math/index.html - - /math-and-statistics/index.html - - /math-and-stats/index.html - - /machine-learning/index.html ---- - -Data science is the application of statistical analysis, machine learning, data visualization and programming to -real-world data sources to bring understanding and insight to data-oriented problem domains. -F# is an excellent solution for programmatic data science as it combines efficient execution, -REPL-scripting, powerful libraries and scalable data integration. - -
-

To contribute to this guide edit this page. These resources are for educational purposes.

-
- -* auto-gen TOC: -{:toc} - -
-## Jupyter Notebooks - -* ![logo](../../images/thumbs/jupyter.png) [.NET Interactive](https://github.com/dotnet/interactive/) -provides data scientists and developers a way to explore data, experiment with code, and try new ideas -effortlessly using .NET Core. Use .NET Interactive to build .NET Jupyter notebooks or custom interactive coding experiences. - -
-## Integrated Packages -{: #integrated-packages .anchor } - - * [FsLab](http://fslab.org/) is the F# Community Project Incubation Space For Data Science. - - * [ML.NET](https://dotnet.microsoft.com/apps/machinelearning-ai/ml-dotnet/) - ML.NET is an open source and cross-platform machine learning framework sponsored by Microsoft. With ML.NET, you can create custom ML models using C# or F# without having to leave the .NET ecosystem. ML.NET lets you re-use all the knowledge, skills, code, and libraries you already have as a .NET developer so that you can easily integrate machine learning into your web, mobile, desktop, games, and IoT apps. - - * [SciSharp Stack](https://scisharp.github.io/SciSharp/) - A .NET based Open Source Ecosystem for Data Science, Machine Learning and AI. - SciSharp provides ports and bindings to cutting edge Machine Learning frameworks like [TensorFlow](https://scisharp.github.io/TensorFlow.NET/), [Keras](https://scisharp.github.io/Keras.NET/), [PyTorch](https://github.com/SciSharp/Torch.NET), [Numpy](https://github.com/SciSharp/NumSharp) and many more in .NET Core. Since the APIs of the ported libraries are so similar to the originals you can easily re-use all existing resources, documentation and community solutions to common problems in C# or F# without much effort. License: Various, mostly Apache 2.0 or MIT - -
-## Interactive Charting -{: #charting .anchor } - -* [XPlot](http://fslab.org/XPlot/) - XPlot is a data visualization package for the F# programming language powered by popular JavaScript charting libraries. It uses Google and Plotly's powerful and free data visualization libraries based on HTML5/SVG technology. You can access the HTML for the charts programatically and use the library from F# Interactive by displaying browser windows. - -* [Plotly.NET](https://github.com/plotly/Plotly.NET/) - a powerful and free charting library. Plotly.NET provides Plotly's awesome graphing support with strongly typed style options for F#. - -
-## Individual Packages -{: .anchor } - -If a resource specific to F# can't be found, then search for C# instead and adjust the technique appropriately. - - * [Math.NET Numerics](http://numerics.mathdotnet.com/) - provides - a large collection of algorithms needed in science and engineering, including linear algebra, - special functions, statistics, probability models, interpolation and FFTs. - In addition to the core .NET package, Numerics specifically supports F# 4.0 with idiomatic extension modules and - maintains mathematical data structures like BigRational that originated in the F# PowerPack. - If a performance boost is needed, the managed-code provider backing its linear algebra routines - and decompositions can be exchanged with wrappers for optimized native implementations such as - Intel MKL. License: MIT/X11 - - * [TensorFlow.NET](https://scisharp.github.io/TensorFlow.NET/) - .NET Standard bindings for Google's TensorFlow for developing, training and deploying Machine Learning models in C# and F#. - - * [TorchSharp](https://github.com/xamarin/TorchSharp) - .NET bindings for PyTorch. Machine Learning with C# / F# with Multi-GPU/CPU support - - * [DiffSharp](http://diffsharp.github.io/) - An automatic differentiation (AD) library for incorporating derivative calculations with minimal changes into existing code, providing exact and efficient gradients, Jacobians and Hessians for machine learning and optimization applications. - - * [SharpCV](https://github.com/SciSharp/SharpCV) - A Computer Vision library combines OpenCV and NDArray together in .NET Standard. - - * [MxNet.Sharp](https://github.com/SciSharp/MxNet.Sharp) - .NET Standard bindings for Apache MxNet with Imperative, Symbolic and Gluon Interface for developing, training and deploying Machine Learning models in C# and F#. - - * [FsAlg](http://gbaydin.github.io/FsAlg/) - A lightweight linear algebra library that supports generic types. - - The library provides generic Vector and Matrix types that support most of the commonly used linear algebra operations, including matrix–vector operations, matrix inverse, determinants, eigenvalues, LU and QR decompositions. Its intended use is to enable writing generic linear algebra code with custom numeric types. It can also be used as a lightweight library for prototyping and scripting with primitive floating point types. - - * [Ariadne](http://evelinag.com/Ariadne/) - Library for fitting Gaussian process regression models. - - * [Numl](http://numl.net/) - A machine learning library intended to ease the use of using standard modeling techniques for both prediction and clustering - - * [Deedle](http://fslab.org/Deedle/) is an easy-to-use, high quality - package for data and time series manipulation and for scientific programming. - It uses a design similar to the Pandas library from Python and the 'tseries' or 'zoo' packages in R, though - with stronger typing. Deedle supports working with structured data frames, ordered and unordered data, as well as time series. Deedle is designed to - work well for exploratory programming using F# and C# interactive console, but can be also used in - efficient compiled .NET code. - -
-## Commercial packages -{: #commercial-packages .anchor } - - * [ILNumerics](http://ilnumerics.net/) - an open- or closed-source library offering high- - performance numerical algorithms as well as charting and plotting capabilities. - - The library is based on efficient, general-purpose array classes implementing vectors, matrices, and - n-dimensional arrays. Provided algorithms include standard linear algebra transforms, - a high-performance Fast Fourier Transform (FFT) library, and a collection of sorting - and machine learning algorithms. Plotting is based on OpenGL and supports both 2D and 3D - plots. - - License: GPLv3 or commercial (paid) license. - - * [Extreme Optimization Numerical Libraries for .NET](http://www.extremeoptimization.com/) - - a set of three libraries focused on vector and matrix processing, - linear algebra methods, and statistics functions. - - The library includes a large selection of - standard algorithms from matrix factorization, function optimization, numerical integration, - K-means clustering, and PCA (principal component analysis). Options are provided to run - using pure managed code for portability or to utilize highly tuned native code for - additional performance. - - * [NMath, NMath Stats](https://www.centerspace.net/nmath/) - - a suite providing core math and statistics functions. - - NMath provides sparse- and - dense-matrix manipulations, FFT algorithms, and numeric algorithms such as curve-fitting, - integration, and differentiation. NMath Stats is built on NMath and provides statistics - functions such multiple linear regression, hypothesis testing, and nonnegative matrix - factorization. NMath and NMath Stats support .NET 4.5 and are available from - [CenterSpace Software](http://www.centerspace.net/). - - * [F# for Numerics](http://www.ffconsultancy.com/products/fsharp_for_numerics/) - - a collection of numeric algorithms including matrix operations, optimization and - interpolation functions, 1D and 2D FFTs, and pseudo-random number generation. - - The library uses - the standard F# PowerPack Matrix for compatibility. F# for Numerics supports .NET. - The library is available from [Flying Frog Consultancy](http://www.ffconsultancy.com/). - - * [F# for Visualization](http://www.ffconsultancy.com/products/fsharp_for_visualization/index.html) - - a 2D and 3D vector graphics library with a native F# interface. - - The package provides interactive plotting from within Visual Studio and support for generating - animations. F# for Visualization supports .NET. The library is - available from [Flying Frog Consultancy](http://www.ffconsultancy.com/). - - -
- -## Interoperability - -### F# and Excel -{: #excel-interop .anchor } - -[Excel-DNA](http://excel-dna.net/) is an independent project to integrate .NET into Excel. With Excel-DNA you can make native (.xll) add-ins for Excel using C#, Visual Basic.NET or F#, providing high-performance user-defined functions (UDFs), custom ribbon interfaces -and more. Your entire add-in can be packed into a single .xll file requiring no installation or registration: - - * [Excel-DNA home pages](http://excel-dna.net/) - * [Async and event-streaming Excel UDFs with F#](https://excel-dna.net/blog/2013/03/26/async-and-event-streaming-excel-udfs-with-f) - -[Sharp Cells](https://www.sharpcells.com/) is another independent project which integrates F# scripting with Excel. It exposes the scripts as either user-defined functions (UDFs) using [Excel's XLL API](https://learn.microsoft.com/en-us/office/client-developer/excel/welcome-to-the-excel-software-development-kit) or commands using [Excel's COM API](https://learn.microsoft.com/en-us/dotnet/api/microsoft.office.interop.excel?view=excel-pia). Compilation takes place at runtime allowing rapid iteration of your code and the scripts are embedded with the workbook maintaining single-file portability similar to VBA. - - * [Getting started](https://www.sharpcells.com/getting-started) - * [Working with asynchronous calculations](https://www.sharpcells.com/example-async) - * Integration with [AngouriMath](https://am.angouri.org/) to [perform symbolic algebra](https://www.sharpcells.com/example-symbolic) - -[NPOI](https://github.com/nissl-lab/npoi/) is .NET version of POI Java project at http://poi.apache.org/. POI is an open source project which can help you read/write xls, doc, ppt files. - -NPOI manipulates the Open Office XML format directly so does not require having Excel installed and do not use Interop. You can read, create, and edit Excel documents using this approach. - - * [Charting with Excel from F#](http://bit.ly/GGv8z4) - -There are also some F# versions of Excel functions, useful when migrating code: - - * [Excel Financial Functions for .NET](https://github.com/fsprojects/ExcelFinancialFunctions) - -
- -### F# and R -{: #r-interop .anchor } - -Resources: - - * [R Type Provider for F#](http://fslab.org/RProvider) - An F# type provider for high fidelity integration between F# and R - * [R.NET](https://github.com/jmp75/rdotnet) - Core interoperability component used by the R Type Provider with some F# extensions. - * [Using F#, R and GGPlot2](http://stackoverflow.com/questions/16820211/r-type-provider-and-ggplot2) - -
- -### F# and MATLAB -{: #matlab-interop .anchor } - -Resources: - - * [MATLAB Type Provider for F#](http://bayardrock.github.io/Matlab-Type-Provider/) - An F# type provider for higher-fidelity integration between F# and MATLAB - -
- -### F# and Python -{: #python-interop .anchor } - -Resources: - - * [Python for .NET](http://pythonnet.github.io/) - Allows Python to be integrated into F# and C# programs - * [Tutorial: Charting with Gnuplot from F#](http://bit.ly/14RwJeW) - -
- -### F# and Mathematica/Wolfram Language -{: #mathematica-interop .anchor } - -Resources: - - * [Calling Mathematica from F#](http://reference.wolfram.com/legacy/v8/NETLink/tutorial/CallingMathematicaFromNET.html) - techniques to call Mathematica from C#, F# and other .NET languages - - * [Calling Wolfram Language from F#](http://reference.wolfram.com/language/NETLink/tutorial/CallingTheWolframLanguageFromNET.html) - techniques to call Mathematica from .NET +--- +layout: default +title: Guide - Data Science | fsharp.org +headline: Guide - Data Science with F# +redirect_from: + - /math/index.html + - /math-and-statistics/index.html + - /math-and-stats/index.html + - /machine-learning/index.html +--- + +Data science is the application of statistical analysis, machine learning, data visualization and programming to +real-world data sources to bring understanding and insight to data-oriented problem domains. +F# is an excellent solution for programmatic data science as it combines efficient execution, +REPL-scripting, powerful libraries and scalable data integration. + +
+

To contribute to this guide edit this page. These resources are for educational purposes.

+
+ +* auto-gen TOC: +{:toc} + +
+## Jupyter Notebooks + +* ![logo](../../images/thumbs/jupyter.png) [.NET Interactive](https://github.com/dotnet/interactive/) +provides data scientists and developers a way to explore data, experiment with code, and try new ideas +effortlessly using .NET Core. Use .NET Interactive to build .NET Jupyter notebooks or custom interactive coding experiences. + +
+## Integrated Packages +{: #integrated-packages .anchor } + +* [FsLab](http://fslab.org/) is the F# Community Project Incubation Space For Data Science. + +* [ML.NET](https://dotnet.microsoft.com/apps/machinelearning-ai/ml-dotnet/) - ML.NET is an open source and cross-platform machine learning framework sponsored by Microsoft. With ML.NET, you can create custom ML models using C# or F# without having to leave the .NET ecosystem. ML.NET lets you re-use all the knowledge, skills, code, and libraries you already have as a .NET developer so that you can easily integrate machine learning into your web, mobile, desktop, games, and IoT apps. + +* [SciSharp Stack](https://scisharp.github.io/SciSharp/) - A .NET based Open Source Ecosystem for Data Science, Machine Learning and AI. + SciSharp provides ports and bindings to cutting edge Machine Learning frameworks like [TensorFlow](https://scisharp.github.io/TensorFlow.NET/), [Keras](https://scisharp.github.io/Keras.NET/), [PyTorch](https://github.com/SciSharp/Torch.NET), [Numpy](https://github.com/SciSharp/NumSharp) and many more in .NET Core. Since the APIs of the ported libraries are so similar to the originals you can easily re-use all existing resources, documentation and community solutions to common problems in C# or F# without much effort. License: Various, mostly Apache 2.0 or MIT + +
+## Interactive Charting +{: #charting .anchor } + +* [XPlot](http://fslab.org/XPlot/) - XPlot is a data visualization package for the F# programming language powered by popular JavaScript charting libraries. It uses Google and Plotly's powerful and free data visualization libraries based on HTML5/SVG technology. You can access the HTML for the charts programatically and use the library from F# Interactive by displaying browser windows. + +* [Plotly.NET](https://github.com/plotly/Plotly.NET/) - a powerful and free charting library. Plotly.NET provides Plotly's awesome graphing support with strongly typed style options for F#. + +
+## Individual Packages +{: .anchor } + +If a resource specific to F# can't be found, then search for C# instead and adjust the technique appropriately. + +* [Math.NET Numerics](http://numerics.mathdotnet.com/) - provides + a large collection of algorithms needed in science and engineering, including linear algebra, + special functions, statistics, probability models, interpolation and FFTs. + In addition to the core .NET package, Numerics specifically supports F# 4.0 with idiomatic extension modules and + maintains mathematical data structures like BigRational that originated in the F# PowerPack. + If a performance boost is needed, the managed-code provider backing its linear algebra routines + and decompositions can be exchanged with wrappers for optimized native implementations such as + Intel MKL. License: MIT/X11 + +* [TensorFlow.NET](https://scisharp.github.io/TensorFlow.NET/) - .NET Standard bindings for Google's TensorFlow for developing, training and deploying Machine Learning models in C# and F#. + +* [TorchSharp](https://github.com/xamarin/TorchSharp) - .NET bindings for PyTorch. Machine Learning with C# / F# with Multi-GPU/CPU support + +* [DiffSharp](http://diffsharp.github.io/) - An automatic differentiation (AD) library for incorporating derivative calculations with minimal changes into existing code, providing exact and efficient gradients, Jacobians and Hessians for machine learning and optimization applications. + +* [SharpCV](https://github.com/SciSharp/SharpCV) - A Computer Vision library combines OpenCV and NDArray together in .NET Standard. + +* [MxNet.Sharp](https://github.com/SciSharp/MxNet.Sharp) - .NET Standard bindings for Apache MxNet with Imperative, Symbolic and Gluon Interface for developing, training and deploying Machine Learning models in C# and F#. + +* [FsAlg](http://gbaydin.github.io/FsAlg/) - A lightweight linear algebra library that supports generic types. + + The library provides generic Vector and Matrix types that support most of the commonly used linear algebra operations, including matrix–vector operations, matrix inverse, determinants, eigenvalues, LU and QR decompositions. Its intended use is to enable writing generic linear algebra code with custom numeric types. It can also be used as a lightweight library for prototyping and scripting with primitive floating point types. + +* [Ariadne](http://evelinag.com/Ariadne/) - Library for fitting Gaussian process regression models. + +* [Numl](http://numl.net/) - A machine learning library intended to ease the use of using standard modeling techniques for both prediction and clustering + +* [Deedle](http://fslab.org/Deedle/) is an easy-to-use, high quality + package for data and time series manipulation and for scientific programming. + It uses a design similar to the Pandas library from Python and the 'tseries' or 'zoo' packages in R, though + with stronger typing. Deedle supports working with structured data frames, ordered and unordered data, as well as time series. Deedle is designed to + work well for exploratory programming using F# and C# interactive console, but can be also used in + efficient compiled .NET code. + +
+## Commercial packages +{: #commercial-packages .anchor } + +* [ILNumerics](http://ilnumerics.net/) - an open- or closed-source library offering high- + performance numerical algorithms as well as charting and plotting capabilities. + + The library is based on efficient, general-purpose array classes implementing vectors, matrices, and + n-dimensional arrays. Provided algorithms include standard linear algebra transforms, + a high-performance Fast Fourier Transform (FFT) library, and a collection of sorting + and machine learning algorithms. Plotting is based on OpenGL and supports both 2D and 3D + plots. + + License: GPLv3 or commercial (paid) license. + +* [Extreme Optimization Numerical Libraries for .NET](http://www.extremeoptimization.com/) - + a set of three libraries focused on vector and matrix processing, + linear algebra methods, and statistics functions. + + The library includes a large selection of + standard algorithms from matrix factorization, function optimization, numerical integration, + K-means clustering, and PCA (principal component analysis). Options are provided to run + using pure managed code for portability or to utilize highly tuned native code for + additional performance. + +* [NMath, NMath Stats](https://www.centerspace.net/nmath/) - + a suite providing core math and statistics functions. + + NMath provides sparse- and + dense-matrix manipulations, FFT algorithms, and numeric algorithms such as curve-fitting, + integration, and differentiation. NMath Stats is built on NMath and provides statistics + functions such multiple linear regression, hypothesis testing, and nonnegative matrix + factorization. NMath and NMath Stats support .NET 4.5 and are available from + [CenterSpace Software](http://www.centerspace.net/). + +* [F# for Numerics](http://www.ffconsultancy.com/products/fsharp_for_numerics/) - + a collection of numeric algorithms including matrix operations, optimization and + interpolation functions, 1D and 2D FFTs, and pseudo-random number generation. + + The library uses + the standard F# PowerPack Matrix for compatibility. F# for Numerics supports .NET. + The library is available from [Flying Frog Consultancy](http://www.ffconsultancy.com/). + +* [F# for Visualization](http://www.ffconsultancy.com/products/fsharp_for_visualization/index.html) - + a 2D and 3D vector graphics library with a native F# interface. + + The package provides interactive plotting from within Visual Studio and support for generating + animations. F# for Visualization supports .NET. The library is + available from [Flying Frog Consultancy](http://www.ffconsultancy.com/). + +
+ +## Interoperability + +### F# and Excel + +{: #excel-interop .anchor } + +[Excel-DNA](http://excel-dna.net/) is an independent project to integrate .NET into Excel. With Excel-DNA you can make native (.xll) add-ins for Excel using C#, Visual Basic.NET or F#, providing high-performance user-defined functions (UDFs), custom ribbon interfaces +and more. Your entire add-in can be packed into a single .xll file requiring no installation or registration: + +* [Excel-DNA home pages](http://excel-dna.net/) +* [Async and event-streaming Excel UDFs with F#](https://excel-dna.net/blog/2013/03/26/async-and-event-streaming-excel-udfs-with-f) + +[Sharp Cells](https://www.sharpcells.com/) is another independent project which integrates F# scripting with Excel. It exposes the scripts as either user-defined functions (UDFs) using [Excel's XLL API](https://learn.microsoft.com/en-us/office/client-developer/excel/welcome-to-the-excel-software-development-kit) or commands using [Excel's COM API](https://learn.microsoft.com/en-us/dotnet/api/microsoft.office.interop.excel?view=excel-pia). Compilation takes place at runtime allowing rapid iteration of your code and the scripts are embedded with the workbook maintaining single-file portability similar to VBA. + +* [Getting started](https://www.sharpcells.com/getting-started) +* [Working with asynchronous calculations](https://www.sharpcells.com/example-async) +* Integration with [AngouriMath](https://am.angouri.org/) to [perform symbolic algebra](https://www.sharpcells.com/example-symbolic) + +[NPOI](https://github.com/nissl-lab/npoi/) is .NET version of POI Java project at . POI is an open source project which can help you read/write xls, doc, ppt files. + +NPOI manipulates the Open Office XML format directly so does not require having Excel installed and do not use Interop. You can read, create, and edit Excel documents using this approach. + +* [Charting with Excel from F#](http://bit.ly/GGv8z4) + +There are also some F# versions of Excel functions, useful when migrating code: + +* [Excel Financial Functions for .NET](https://github.com/fsprojects/ExcelFinancialFunctions) + +
+ +### F# and R + +{: #r-interop .anchor } + +Resources: + +* [R Type Provider for F#](http://fslab.org/RProvider) - An F# type provider for high fidelity integration between F# and R +* [R.NET](https://github.com/jmp75/rdotnet) - Core interoperability component used by the R Type Provider with some F# extensions. +* [Using F#, R and GGPlot2](http://stackoverflow.com/questions/16820211/r-type-provider-and-ggplot2) + +
+ +### F# and MATLAB + +{: #matlab-interop .anchor } + +Resources: + +* [MATLAB Type Provider for F#](http://bayardrock.github.io/Matlab-Type-Provider/) - An F# type provider for higher-fidelity integration between F# and MATLAB + +
+ +### F# and Python + +{: #python-interop .anchor } + +Resources: + +* [Python for .NET](http://pythonnet.github.io/) - Allows Python to be integrated into F# and C# programs +* [Tutorial: Charting with Gnuplot from F#](http://bit.ly/14RwJeW) + +
+ +### F# and Mathematica/Wolfram Language + +{: #mathematica-interop .anchor } + +Resources: + +* [Calling Mathematica from F#](http://reference.wolfram.com/legacy/v8/NETLink/tutorial/CallingMathematicaFromNET.html) - techniques to call Mathematica from C#, F# and other .NET languages + +* [Calling Wolfram Language from F#](http://reference.wolfram.com/language/NETLink/tutorial/CallingTheWolframLanguageFromNET.html) - techniques to call Mathematica from .NET diff --git a/guides/engineering/issues.md b/guides/engineering/issues.md index d5b0d11c..9644c258 100644 --- a/guides/engineering/issues.md +++ b/guides/engineering/issues.md @@ -20,7 +20,6 @@ Please follow the links below to make a suggestion, report an issue with F# and/ | [VS Code (F# Ionide Tools)](https://ionide.io/) | [Make suggestion](https://github.com/ionide/ionide-vscode-fsharp) | [Report/Fix an issue](https://github.com/ionide/ionide-vscode-fsharp) | | Other F# Editing Tools | ([Emacs](https://github.com/fsharp/emacs-fsharp-mode), [Vim](https://github.com/fsharp/vim-fsharp), [Sublime](https://github.com/fsharp/sublime-fsharp-package), ...) | | - ### Other Components and Tools For other components and tools, please [refer to the relevant project](/community/projects). Some specific links are shown below. @@ -29,6 +28,4 @@ For other components and tools, please [refer to the relevant project](/communit | [.NET Core Runtime](https://dotnet.microsoft.com/) | [Make suggestion](https://github.com/dotnet/coreclr) | [Report/Fix an issue](https://github.com/dotnet/coreclr) | | [.NET Core Libraries](https://dotnet.microsoft.com/) | [Make suggestion](https://github.com/dotnet/corefx) | [Report/Fix an issue](https://github.com/dotnet/corefx) | - - You can contribute to this page [by proposing an edit](https://github.com/fsharp/fsharp.org/edit/main/guides/engineering/issues.md). diff --git a/guides/enterprise/index.md b/guides/enterprise/index.md index e51cfb32..f01b8467 100644 --- a/guides/enterprise/index.md +++ b/guides/enterprise/index.md @@ -63,14 +63,12 @@ Many developers have posted on why they like F#: * [Why F#?](http://davefancher.com/2013/01/27/why-f/) * [A list of many other "Why F#" posts](https://sergeytihon.wordpress.com/2013/03/24/why-f-by-f-weekly/). - ### A tour of F# features ### * [An introduction to F#](https://channel9.msdn.com/blogs/pdc2008/tl11) (video). * [Why use F#?](http://fsharpforfunandprofit.com/series/why-use-fsharp.html). This series of posts will give you a guided tour through the main features of F#. - ### Low risk ways to use F# ### You can easily try out F# for non-critical development tasks such as testing and scripting without committing to wholesale change. @@ -163,15 +161,15 @@ safe parallelization with immutable data, and more. #### Asynchronous programming in F# #### - * [Async in C# and F#: An introduction](http://tomasp.net/blog/csharp-fsharp-async-intro.aspx/) - * [Async in C# and F#: Asynchronous gotchas in C#](http://tomasp.net/blog/csharp-async-gotchas.aspx/). Why the F# async library is safer than the C# one. - * [Writing non-blocking user-interfaces in F#](http://tomasp.net/blog/async-non-blocking-gui.aspx/) - * [Asynchronous programming: another introduction](http://fsharpforfunandprofit.com/posts/concurrency-async-and-parallel/) +* [Async in C# and F#: An introduction](http://tomasp.net/blog/csharp-fsharp-async-intro.aspx/) +* [Async in C# and F#: Asynchronous gotchas in C#](http://tomasp.net/blog/csharp-async-gotchas.aspx/). Why the F# async library is safer than the C# one. +* [Writing non-blocking user-interfaces in F#](http://tomasp.net/blog/async-non-blocking-gui.aspx/) +* [Asynchronous programming: another introduction](http://fsharpforfunandprofit.com/posts/concurrency-async-and-parallel/) #### Agents and message queues #### - * [An Introduction To F# Agents](http://www.developerfusion.com/article/139804/an-introduction-to-f-agents/) - * [Agents](http://fsharpforfunandprofit.com/posts/concurrency-actor-model/). Another introduction +* [An Introduction To F# Agents](http://www.developerfusion.com/article/139804/an-introduction-to-f-agents/) +* [Agents](http://fsharpforfunandprofit.com/posts/concurrency-actor-model/). Another introduction ### Developer morale diff --git a/guides/slack/index.md b/guides/slack/index.md index 7e7ef7e4..26bd883a 100644 --- a/guides/slack/index.md +++ b/guides/slack/index.md @@ -6,7 +6,7 @@ headline: F# Slack Team ## F# on Slack -[Slack](https://slack.com/) is a persistent chat service. +[Slack](https://slack.com/) is a persistent chat service. Members of the F# Software Foundation are invited to the [F# Software Foundation](https://fsharp.slack.com/) team. To join, become a member of the F# Software Foundation by [visiting this page](https://foundation.fsharp.org/join). Once you are a member, you will automatically be queued to receive an invite to the Foundation's Slack team. @@ -19,6 +19,6 @@ Once you sign into the Slack team, there are various channels containing topics * [#code](https://fsharp.slack.com/messages/code/): Code-focused discussion on any F# related topic * [#web](https://fsharp.slack.com/messages/web/): Discussion focused on using F# with web based technologies -If you don't receive the invite within 48 hours, or if you have any questions, please send an email to info@fsharp.org to follow up. +If you don't receive the invite within 48 hours, or if you have any questions, please send an email to to follow up. History within Slack is limited. We recommend using the [F# Discord Forums](https://discord.gg/R6n7c54) for questions or discussions where persistance and history are important. diff --git a/guides/web/index.md b/guides/web/index.md index 32a48226..20337625 100644 --- a/guides/web/index.md +++ b/guides/web/index.md @@ -32,6 +32,7 @@ well to a stateless, functional approach. Advantages to using F# for web program ## Integrated Stacks #### SAFE Stack + {: #safe-stack .anchor } ![logo](../../images/thumbs/safestack.png) [SAFE Stack](https://safe-stack.github.io/) is an end-to-end, functional-first stack for cloud-ready web development that @@ -46,6 +47,7 @@ coherent stack for type-safe, flexible, web-enabled applications that can be wri
#### WebSharper + {: #websharper .anchor } ![logo](../../images/thumbs/WebSharper.png) [WebSharper](http://websharper.com/) allows end-to-end web applications with both client and server developed in F#. @@ -60,6 +62,7 @@ It includes TypeScript interoperability, mobile web apps, getting started materi
#### Fable + {: #fable .anchor } ![logo](../../images/thumbs/fable.png) [Fable](http://fable.io/) is an F# to JS compiler designed to generate clean @@ -77,6 +80,7 @@ and mobile apps with [React native](https://facebook.github.io/react-native/).
#### Giraffe + {: #giraffe .anchor } ![logo](../../images/thumbs/giraffe.png) [Giraffe](https://github.com/giraffe-fsharp/Giraffe) is an F# library for building rich web applications that use ASP.NET Core under the hood. It has been heavily inspired and is similar to [Suave](https://suave.io/), but has been specifically designed with [ASP.NET Core](https://www.asp.net/core) in mind and can be plugged into the ASP.NET Core pipeline via [middleware](https://docs.microsoft.com/aspnet/core/fundamentals/middleware). @@ -87,8 +91,8 @@ and mobile apps with [React native](https://facebook.github.io/react-native/).
- #### ASP.NET Core + {: #aspnetcore .anchor } [ASP.NET Core](https://www.asp.net/core) is a modern, cross-platform, high-performance, open-source framework for building modern, cloud-based, Internet-connected applications. It runs on .NET Core and supports F# out of the box. If you install the [.NET Core SDK](https://www.microsoft.com/net/download/core), there are F# templates available via the `dotnet new` command. @@ -98,6 +102,7 @@ and mobile apps with [React native](https://facebook.github.io/react-native/).
#### Suave + {: #suave .anchor } ![logo](../../images/thumbs/suave.png) [Suave](http://suave.io/) is a simple web development F# library providing a lightweight web server and a set of combinators to manipulate route flow and task composition. @@ -105,6 +110,7 @@ and mobile apps with [React native](https://facebook.github.io/react-native/).
#### Saturn + {: #saturn .anchor } ![logo](../../images/thumbs/saturn.png) [Saturn](https://saturnframework.org) is a web development framework written in F# which implements the server-side MVC pattern. Many of its components and concepts will seem familiar to anyone with experience in other web frameworks like Ruby on Rails or Python’s Django. It's built on top of Giraffe and ASP.Net Core - modern, cross-platform, high-performance development platform for building cloud-ready web applications. @@ -126,16 +132,14 @@ It's heavily inspired by Elixir's [Phoenix](http://phoenixframework.org/). * [Project Template](https://github.com/fsbolero/template) * [Try Online](https://tryfsharp.fsbolero.io/) -
- #### Falco + {: #falco .anchor } [Falco](https://github.com/pimbrouwers/Falco) is a functional-first toolkit for building brilliant ASP.NET Core applications using F#. It is built upon the high-performance primitives of ASP.NET Core, optimized for building HTTP applications quickly, and seamlessly integrates with existing .NET Core middleware and frameworks. - * [NuGet](https://www.nuget.org/packages/Falco/) * [GitHub](https://github.com/pimbrouwers/Falco) * [Docs](https://www.falcoframework.com/) @@ -144,21 +148,23 @@ It's heavily inspired by Elixir's [Phoenix](http://phoenixframework.org/).
#### ServiceStack + {: #service-stack .anchor } [ServiceStack](https://servicestack.net/) is a framework for simple and fast web services on .NET.
- ------ ## Web Testing Frameworks + {: .anchor }
#### Canopy for Client-side Testing + {: #canopy .anchor } [canopy](http://lefthandedgoat.github.io/canopy/) is a web testing framework built on top of selenium and written in F#. It's syntax is clean and @@ -167,6 +173,7 @@ concise. You can easily leverage your existing .NET code to help you test.
#### Unit Testing Libraries + {: .anchor } Some open source libraries that assist with web unit testing are: @@ -183,15 +190,16 @@ Some open source libraries that assist with web unit testing are: * [Unquote](https://github.com/SwensenSoftware/unquote/) - ------ ## Live Examples + {: .anchor }
#### TodoBackend + {: .anchor } [TodoBackend](http://todobackend.com/) is a project that aims to be "a shared example to showcase backend tech stacks." The F# community has contributed some examples, and a few more are in progress: @@ -205,6 +213,7 @@ Please consider contributing, either directly to the TodoBackend project or via ------ ## Tutorials + {: .anchor } * [Suave Music Store Tutorial](https://www.gitbook.com/book/theimowski/suave-music-store) for creating applications with Suave.IO @@ -212,6 +221,7 @@ Please consider contributing, either directly to the TodoBackend project or via ------ ## Books + {: .anchor } Several books have been written that include information on building web applications with F#: @@ -223,6 +233,7 @@ Several books have been written that include information on building web applica ------ ## Presentations + {: .anchor } There are several presentations and tutorials available that include information on @@ -247,6 +258,7 @@ build web applications with F#: ------ ## Hosting + {: .anchor } Common hosting options are: diff --git a/learn/index.md b/learn/index.md index 624d6429..aab37bb2 100644 --- a/learn/index.md +++ b/learn/index.md @@ -1,92 +1,86 @@ ---- -layout: default -title: Learning F# | fsharp.org -headline: Learning F# -redirect_from: - - "/consulting/" - - "/training/" - - "/learn.html" - - "/about/" - - "/about/learning/" - - "/about/learning.html" ---- - -To learn F# use one of the free online resources, courses or books below. - -### [F# Basics](https://dotnet.microsoft.com/languages/fsharp) - -A simple, clear resource explaining what F# is and what it is for. -Learn about the tools for F#, the F# community, using F# with the .NET platform and access getting-started material. - -### [Beginning F# (Video Series)](https://www.youtube.com/playlist?list=PLdo4fOcmZ0oUFghYOp89baYFBTGxUkC7Z) - -Join Luis to get started with F# through a sequence of short, 10-minute videos. -This series explains how F# is an open-source, cross-platform programming language that makes it easy to write succinct, performant, robust, and practical code -and gives you what you need to get started. - -### [F# from the Ground Up (Course)](https://www.udemy.com/course/fsharp-from-the-ground-up) - -Whether it's your first programming language or your next, F# will transform your experience as a software developer. Requiring nothing more than basic computer literacy, this course teaches you how to write software in F#. - -### [F# for C#, Java or Python developers](http://fsharpforfunandprofit.com/) - - - -Introduces you to F# and show you ways that F# can help in day-to-day development -of mainstream commercial business software. - -### [F# Cheat Sheet](http://fsprojects.github.io/fsharp-cheatsheet/) - - - -The cheat sheet is a small and concise guide to F# syntax for newcomers to get started with the language. It's available in [HTML](http://fsprojects.github.io/fsharp-cheatsheet/) and [PDF](https://fsprojects.github.io/fsharp-cheatsheet/fsharp-cheatsheet.pdf) format. - -### [F# Guide for Python developers](https://github.com/knocte/2fsharp/blob/master/python2fsharp.md) - -Very short tutorial/guide that shows the most important differences between Python and F#, with clear and concise examples. - -### [F# Guide for C# developers](https://github.com/knocte/2fsharp/blob/master/csharp2fsharp.md) - -Very short tutorial/guide that shows the most important differences between C# and F#, with clear and concise examples. - -### [Exercism](https://exercism.io/tracks/fsharp) - -Learn F# by solving problems, testing your solutions, getting feedback from other developers, and reviewing other developers' solutions! At last check, there are 112 F# problems just waiting for you to solve them. - -### [F# Bite-sized (course)](https://fsbitesized.com/) - -Eager to learn F#? Learning a new language, yet a new paradigm, can be very daunting. This course aims to give you an interactive, gentle and fun introduction to F#. Video lectures, presentation slides, code samples, quizzes and exercises (with solution) will be present throughout the course – all at your pace. I’ll take you through topics such as introduction to Functional Programming, Function Composition, Partial Application, Testing in F#, Async Programming in F#, Algebraic Types (Records and Unions), Railway Oriented Programming (ROP) and many more. - -### [F# Programming Wikibook](http://en.wikibooks.org/wiki/Programming:F_Sharp) - -The wikibook contains a comprehensive guide to F# programming. It covers -F# language basics and essential functional programming concepts such as -working with functions and immutable data structures. It also discusses -imperative and object-oriented programming in F# and advanced langauge -features such as active patterns and computation expressions. - -### [F# Books]({{ '/learn/books' | relative_url }}) - -We maintain a list of general F# books [here.]({{ '/learn/books' | relative_url }}) - - -

F# Workshops and Dojos

- -### [The F# Koans](https://github.com/ChrisMarinos/FSharpKoans#functional-koans---f) - -Learn F# by just filling in the gaps! The F# Koans are a fun set of code snippets where you have to fill in gaps to get tests to pass, and you learn the language along the way. Also available as a [snippet](http://fssnip.net/bG) which can be loaded into interactive environments or your editor of choice. - -### [F# Workshop Materials](https://github.com/jorgef/fsharpworkshop) - -Material from the F# Introduction Workshop created by Jorge Fioranelli. - -### [Community for F# Coding Dojos](http://c4fsharp.net/#fsharp-coding-dojos) - -A range of coding dojos for F# from [Community for F#](http://c4fsharp.net) including the famous -[Digits Recognizer](https://github.com/c4fsharp/Dojo-Digits-Recognizer), [Fractal Forest](https://github.com/c4fsharp/Dojo-Fractal-Forest), [Canopy 2048](https://github.com/c4fsharp/Dojo-Canopy-2048), -[Markov Bot](https://github.com/c4fsharp/Dojo-Markov-Bot), [Type Provider Treasure Hunt](https://github.com/c4fsharp/Dojo-Type-Provider-Treasure-Hunt), [Classics Mash-up](https://github.com/c4fsharp/Dojo-Picasquez-and-Velasso) and [Ham or Spam](https://github.com/c4fsharp/Dojo-Ham-Or-Spam) dojos. - - - - - +--- +layout: default +title: Learning F# | fsharp.org +headline: Learning F# +redirect_from: + - "/consulting/" + - "/training/" + - "/learn.html" + - "/about/" + - "/about/learning/" + - "/about/learning.html" +--- + +To learn F# use one of the free online resources, courses or books below. + +### [F# Basics](https://dotnet.microsoft.com/languages/fsharp) + +A simple, clear resource explaining what F# is and what it is for. +Learn about the tools for F#, the F# community, using F# with the .NET platform and access getting-started material. + +### [Beginning F# (Video Series)](https://www.youtube.com/playlist?list=PLdo4fOcmZ0oUFghYOp89baYFBTGxUkC7Z) + +Join Luis to get started with F# through a sequence of short, 10-minute videos. +This series explains how F# is an open-source, cross-platform programming language that makes it easy to write succinct, performant, robust, and practical code +and gives you what you need to get started. + +### [F# from the Ground Up (Course)](https://www.udemy.com/course/fsharp-from-the-ground-up) + +Whether it's your first programming language or your next, F# will transform your experience as a software developer. Requiring nothing more than basic computer literacy, this course teaches you how to write software in F#. + +### [F# for C#, Java or Python developers](http://fsharpforfunandprofit.com/) + + + +Introduces you to F# and show you ways that F# can help in day-to-day development +of mainstream commercial business software. + +### [F# Cheat Sheet](http://fsprojects.github.io/fsharp-cheatsheet/) + + + +The cheat sheet is a small and concise guide to F# syntax for newcomers to get started with the language. It's available in [HTML](http://fsprojects.github.io/fsharp-cheatsheet/) and [PDF](https://fsprojects.github.io/fsharp-cheatsheet/fsharp-cheatsheet.pdf) format. + +### [F# Guide for Python developers](https://github.com/knocte/2fsharp/blob/master/python2fsharp.md) + +Very short tutorial/guide that shows the most important differences between Python and F#, with clear and concise examples. + +### [F# Guide for C# developers](https://github.com/knocte/2fsharp/blob/master/csharp2fsharp.md) + +Very short tutorial/guide that shows the most important differences between C# and F#, with clear and concise examples. + +### [Exercism](https://exercism.io/tracks/fsharp) + +Learn F# by solving problems, testing your solutions, getting feedback from other developers, and reviewing other developers' solutions! At last check, there are 112 F# problems just waiting for you to solve them. + +### [F# Bite-sized (course)](https://fsbitesized.com/) + +Eager to learn F#? Learning a new language, yet a new paradigm, can be very daunting. This course aims to give you an interactive, gentle and fun introduction to F#. Video lectures, presentation slides, code samples, quizzes and exercises (with solution) will be present throughout the course – all at your pace. I’ll take you through topics such as introduction to Functional Programming, Function Composition, Partial Application, Testing in F#, Async Programming in F#, Algebraic Types (Records and Unions), Railway Oriented Programming (ROP) and many more. + +### [F# Programming Wikibook](http://en.wikibooks.org/wiki/Programming:F_Sharp) + +The wikibook contains a comprehensive guide to F# programming. It covers +F# language basics and essential functional programming concepts such as +working with functions and immutable data structures. It also discusses +imperative and object-oriented programming in F# and advanced langauge +features such as active patterns and computation expressions. + +### [F# Books]({{ '/learn/books' | relative_url }}) + +We maintain a list of general F# books [here.]({{ '/learn/books' | relative_url }}) + +

F# Workshops and Dojos

+ +### [The F# Koans](https://github.com/ChrisMarinos/FSharpKoans#functional-koans---f) + +Learn F# by just filling in the gaps! The F# Koans are a fun set of code snippets where you have to fill in gaps to get tests to pass, and you learn the language along the way. Also available as a [snippet](http://fssnip.net/bG) which can be loaded into interactive environments or your editor of choice. + +### [F# Workshop Materials](https://github.com/jorgef/fsharpworkshop) + +Material from the F# Introduction Workshop created by Jorge Fioranelli. + +### [Community for F# Coding Dojos](http://c4fsharp.net/#fsharp-coding-dojos) + +A range of coding dojos for F# from [Community for F#](http://c4fsharp.net) including the famous +[Digits Recognizer](https://github.com/c4fsharp/Dojo-Digits-Recognizer), [Fractal Forest](https://github.com/c4fsharp/Dojo-Fractal-Forest), [Canopy 2048](https://github.com/c4fsharp/Dojo-Canopy-2048), +[Markov Bot](https://github.com/c4fsharp/Dojo-Markov-Bot), [Type Provider Treasure Hunt](https://github.com/c4fsharp/Dojo-Type-Provider-Treasure-Hunt), [Classics Mash-up](https://github.com/c4fsharp/Dojo-Picasquez-and-Velasso) and [Ham or Spam](https://github.com/c4fsharp/Dojo-Ham-Or-Spam) dojos. diff --git a/specs/index.md b/specs/index.md index df482668..726fc681 100644 --- a/specs/index.md +++ b/specs/index.md @@ -4,7 +4,6 @@ title: About F# | Specifications headline: Specifications --- - * [The F# Language Specification](language-spec/) - - * [The F# Component Design Guidelines](https://docs.microsoft.com/en-us/dotnet/fsharp/style-guide/component-design-guidelines/) +* [The F# Language Specification](language-spec/) +* [The F# Component Design Guidelines](https://docs.microsoft.com/en-us/dotnet/fsharp/style-guide/component-design-guidelines/) diff --git a/teaching/index.md b/teaching/index.md index f6877b92..16402bbe 100644 --- a/teaching/index.md +++ b/teaching/index.md @@ -1,99 +1,97 @@ ---- -layout: default -title: Teaching F# | fsharp.org -headline: Using F# for teaching ---- - -This page lists some resources for teaching F# in formal settings. - -#### [Teaching programming language concepts with F#](http://channel9.msdn.com/Tags/peter-sestoft) - - Peter Sestoft, IT University of Copenhagen, Denmark - - This is a two-part video lecture by Peter Sestoft, professor from the IT University of Copenhagen, - Denmark. In the lecture, Peter introduces the curriculum, lecture plan and lecture notes - for the course "Programs as data" that uses the functional programming concepts in F# to - teach students language concepts and implemen­tation details. - - - - -#### [Functional Programming Using F#](http://www.imm.dtu.dk/~mire/FSharpBook) - -Michael R. Hansen and Hans Rischel - -This introduction to the principles of functional programming using F# -shows how to apply theoretical concepts to produce succinct and elegant -programs. Coverage includes advanced features in the .NET library, the -imperative features of F# and topics such as sequences, computation -expressions and asynchronous computations. The book contains a broad -spectrum of examples and exercises. - -Further material comprising the programs in the book, lecture slides and -mini-projects are found [on the book web site](http://www.imm.dtu.dk/~mire/FSharpBook/). - -
 
- - - -#### [Programming Language Concepts](http://www.amazon.com/Programming-Language-Concepts-Undergraduate-Computer/dp/1447141555) - -Peter Sestoft - -Programming Language Concepts uses a functional programming language (F#) as the metalanguage in which to -present all concepts and examples, and thus has an operational flavour, enabling practical experiments -and exercises. It includes basic concepts such as abstract syntax, interpretation, stack machines, -compilation, type checking, and garbage collection techniques, as well as the more advanced topics on -polymorphic types, type inference using unification, co- and contravariant types, continuations, and -backwards code generation with on-the-fly peephole optimization. - -Programming Language Concepts covers practical construction of lexers and parsers, but not regular -expressions, automata and grammars, which are well covered elsewhere. It throws light on the design -and technology of Java and C# to strengthen students’ understanding of these widely used languages. -The examples present several interpreters and compilers for toy languages, including a compiler for -a small but usable subset of C, several abstract machines, a garbage collector, and ML-style polymorphic -type inference. Each chapter has exercises based on such examples. - -

Lectures and course material

- -* **[Introduction to functional programming](http://tomasp.net/academic/materials/mff-fsharp-09/)** - Tomas Petricek, Charles University, Czech Republic - - The course explains basic functional concepts such as function composition, functional data - types and higher-order functions. It highlights some interesting connections between these - and concepts that student may already know or will learn in various mathematics lectures. The - site includes lecture slides and a number of simple homeworks that usually require some - interesting insight. - - -* **[Functional Programming with F#](http://www.idt.mdh.se/kurser/DVA229/)** - Björn Lisper, Mälardalen University, Sweden - - The course gives the students a solid under­standing of functional programming, its appli­cations, - and its strengths and weaknesses. It includes topics such as recursion, modern type systems, - higher order functions, lazy evaluation and tradeoffs of using side effects. In addition it - also provides short orientations of lambda calculus and type inference, in order to enhance - the understanding of the functional prog­ramming paradigm. - -* **[Programming Paradigms](http://undergraduate.csse.uwa.edu.au/units/CITS3242/)** - Rowan Davies, The University of Western Australia - - This unit explores and compares the main alternative paradigms for high-level programming. It - considers important modern paradigms such as functional programming, logic programming and concurrent - programming, and compares these with the mainstream paradigms of imperative programming and - object-oriented programming. It considers past and future trends in programming paradigms and - explores the motivation for each paradigm, the concepts which define it, and how each paradigm can - be used in practice to complete programming tasks. It also compares the advantages of each - paradigm in the software production process, with particular emphasis on productivity, - scalability, program behaviour, and the correctness of programs. The unit focuses on both - fundamental concepts and practical software development, with the former enabling the latter. - -* **Functional programming at St Matthews** - Samin Ishtiaq, Microsoft Research Cambridge - - Samin Ishtiaq taught a 1 hour crash course in functional programming to 10/11 year olds at - a local primary school. The course leads up to calculating areas and volumes, which is what - the students were learning in maths at that time. This was the first experience of programming - for almost all of the students. - - The [code](https://github.com/sishtiaq/StMattFP101). +--- +layout: default +title: Teaching F# | fsharp.org +headline: Using F# for teaching +--- + +This page lists some resources for teaching F# in formal settings. + +#### [Teaching programming language concepts with F#](http://channel9.msdn.com/Tags/peter-sestoft) + + Peter Sestoft, IT University of Copenhagen, Denmark + + This is a two-part video lecture by Peter Sestoft, professor from the IT University of Copenhagen, + Denmark. In the lecture, Peter introduces the curriculum, lecture plan and lecture notes + for the course "Programs as data" that uses the functional programming concepts in F# to + teach students language concepts and implemen­tation details. + + + +#### [Functional Programming Using F#](http://www.imm.dtu.dk/~mire/FSharpBook) + +Michael R. Hansen and Hans Rischel + +This introduction to the principles of functional programming using F# +shows how to apply theoretical concepts to produce succinct and elegant +programs. Coverage includes advanced features in the .NET library, the +imperative features of F# and topics such as sequences, computation +expressions and asynchronous computations. The book contains a broad +spectrum of examples and exercises. + +Further material comprising the programs in the book, lecture slides and +mini-projects are found [on the book web site](http://www.imm.dtu.dk/~mire/FSharpBook/). + +
 
+ + + +#### [Programming Language Concepts](http://www.amazon.com/Programming-Language-Concepts-Undergraduate-Computer/dp/1447141555) + +Peter Sestoft + +Programming Language Concepts uses a functional programming language (F#) as the metalanguage in which to +present all concepts and examples, and thus has an operational flavour, enabling practical experiments +and exercises. It includes basic concepts such as abstract syntax, interpretation, stack machines, +compilation, type checking, and garbage collection techniques, as well as the more advanced topics on +polymorphic types, type inference using unification, co- and contravariant types, continuations, and +backwards code generation with on-the-fly peephole optimization. + +Programming Language Concepts covers practical construction of lexers and parsers, but not regular +expressions, automata and grammars, which are well covered elsewhere. It throws light on the design +and technology of Java and C# to strengthen students’ understanding of these widely used languages. +The examples present several interpreters and compilers for toy languages, including a compiler for +a small but usable subset of C, several abstract machines, a garbage collector, and ML-style polymorphic +type inference. Each chapter has exercises based on such examples. + +

Lectures and course material

+ +* **[Introduction to functional programming](http://tomasp.net/academic/materials/mff-fsharp-09/)** + Tomas Petricek, Charles University, Czech Republic + + The course explains basic functional concepts such as function composition, functional data + types and higher-order functions. It highlights some interesting connections between these + and concepts that student may already know or will learn in various mathematics lectures. The + site includes lecture slides and a number of simple homeworks that usually require some + interesting insight. + +* **[Functional Programming with F#](http://www.idt.mdh.se/kurser/DVA229/)** + Björn Lisper, Mälardalen University, Sweden + + The course gives the students a solid under­standing of functional programming, its appli­cations, + and its strengths and weaknesses. It includes topics such as recursion, modern type systems, + higher order functions, lazy evaluation and tradeoffs of using side effects. In addition it + also provides short orientations of lambda calculus and type inference, in order to enhance + the understanding of the functional prog­ramming paradigm. + +* **[Programming Paradigms](http://undergraduate.csse.uwa.edu.au/units/CITS3242/)** + Rowan Davies, The University of Western Australia + + This unit explores and compares the main alternative paradigms for high-level programming. It + considers important modern paradigms such as functional programming, logic programming and concurrent + programming, and compares these with the mainstream paradigms of imperative programming and + object-oriented programming. It considers past and future trends in programming paradigms and + explores the motivation for each paradigm, the concepts which define it, and how each paradigm can + be used in practice to complete programming tasks. It also compares the advantages of each + paradigm in the software production process, with particular emphasis on productivity, + scalability, program behaviour, and the correctness of programs. The unit focuses on both + fundamental concepts and practical software development, with the former enabling the latter. + +* **Functional programming at St Matthews** + Samin Ishtiaq, Microsoft Research Cambridge + + Samin Ishtiaq taught a 1 hour crash course in functional programming to 10/11 year olds at + a local primary school. The course leads up to calculating areas and volumes, which is what + the students were learning in maths at that time. This was the first experience of programming + for almost all of the students. + + The [code](https://github.com/sishtiaq/StMattFP101). diff --git a/testimonials/index.html b/testimonials/index.html index 7997e7e9..d1dafa37 100644 --- a/testimonials/index.html +++ b/testimonials/index.html @@ -1,121 +1,121 @@ ---- -layout: page -title: Testimonials | fsharp.org -headline: Testimonials and Quotes -class: testimonials ---- - - -
-
- -
- -
-
- {% for testimonial in site.testimonials %} -
-
-
- - -
-
- {{ testimonial.quote }} -
-
-
{{ testimonial.content | markdownify }}
-
    - {% for bullet in testimonial.bullets %} -
  • {{ bullet | markdownify }}
    • - {% endfor %} -
-
- -
-
- {% endfor %} -
-
-
- +--- +layout: page +title: Testimonials | fsharp.org +headline: Testimonials and Quotes +class: testimonials +--- + + +
+
+ +
+ +
+
+ {% for testimonial in site.testimonials %} +
+
+
+ + +
+
+ {{ testimonial.quote }} +
+
+
{{ testimonial.content | markdownify }}
+
    + {% for bullet in testimonial.bullets %} +
  • {{ bullet | markdownify }}
    • + {% endfor %} +
+
+ +
+
+ {% endfor %} +
+
+
+ diff --git a/use/browser/index.md b/use/browser/index.md index 8f1eeab4..acecdfb1 100644 --- a/use/browser/index.md +++ b/use/browser/index.md @@ -27,7 +27,6 @@ computer. It includes example code for many of F#'s basic features. [SharpLab](https://sharplab.io/) is a C#/VB/F# compiler playground, allows you to see compiled code including generated assembly code. -
## Registration required @@ -53,4 +52,3 @@ Easiest way to get started with Gitpod is going to [Ionide Playground repository Easiest way to get started with Gitpod is going to [Ionide Playground repository](https://github.com/ionide/playground) and clicking `Open in Gitpod` button
- diff --git a/use/desktop-apps/index.md b/use/desktop-apps/index.md index 90b2b9e5..4bf96e3b 100644 --- a/use/desktop-apps/index.md +++ b/use/desktop-apps/index.md @@ -39,4 +39,3 @@ are available on the web.
There are other options, see also [F# Community Projects](../../community/projects/). - diff --git a/use/mac/index.md b/use/mac/index.md index 036379d3..29c0de6a 100644 --- a/use/mac/index.md +++ b/use/mac/index.md @@ -39,8 +39,6 @@ You will see a message saying "Hello World from F#". For more information see [Getting started with the F# command line tools](https://docs.microsoft.com/dotnet/fsharp/get-started/get-started-command-line). - -
### Option 2: Install Visual Studio Code and Ionide diff --git a/use/mobile-apps/index.md b/use/mobile-apps/index.md index 1455cd58..1d4b6902 100644 --- a/use/mobile-apps/index.md +++ b/use/mobile-apps/index.md @@ -12,12 +12,12 @@ redirect_from: F# supports the development of Android and iOS applications using the [Xamarin](https://dotnet.microsoft.com/apps/xamarin) tools. Both native and cross-platform app development is possible. -1. Install [JetBrains Rider](https://www.jetbrains.com/rider/), or [Visual Studio for Mac](https://visualstudio.microsoft.com/vs/mac/). +1. Install [JetBrains Rider](https://www.jetbrains.com/rider/), or [Visual Studio for Mac](https://visualstudio.microsoft.com/vs/mac/). 2. Select F# Language support as part of installation. [Fabulous](https://fabulous.dev) is a framework for F# Functional App Development, using declarative dynamic UI. -This allows you to use the ultra-simple MVU (Model-View-Update) architecture to build applications for iOS, Android, Mac, WPF and more using Xamarin.Forms. +This allows you to use the ultra-simple MVU (Model-View-Update) architecture to build applications for iOS, Android, Mac, WPF and more using Xamarin.Forms. * [Getting Started with Fabulous](https://docs.fabulous.dev). @@ -25,7 +25,6 @@ This allows you to use the ultra-simple MVU (Model-View-Update) architecture to * [Fabulous Contacts](https://github.com/TimLariviere/FabulousContacts) - A sample contacts app using Fabulous -
### Option 2: Build Android and iOS Apps using F# and React Native @@ -33,7 +32,6 @@ This allows you to use the ultra-simple MVU (Model-View-Update) architecture to F# supports the development of Android and iOS applications using React and React Native. See [this guided example](https://github.com/SAFE-Stack/SAFE-Nightwatch) for starting development. -
There are other options, see also [F# for Mobile Apps](../../guides/mobile-apps/). diff --git a/use/notebooks/index.md b/use/notebooks/index.md index 41b415b5..8f7f7f09 100644 --- a/use/notebooks/index.md +++ b/use/notebooks/index.md @@ -10,13 +10,10 @@ headline: Using F# for Jupyter Notebooks provides data scientists and developers a way to explore data, experiment with code, and try new ideas effortlessly using .NET Core. Use .NET Interactive to build .NET Jupyter notebooks or custom interactive coding experiences. - * [Use in Visual Studio Code](https://github.com/dotnet/interactive/#visual-studio-code) * [Use in Jupyter](https://github.com/dotnet/interactive/#jupyter-and-nteract)
- See also [F# for Data Science](../../guides/data-science/). - diff --git a/use/web-apps/index.md b/use/web-apps/index.md index d4334882..f3d1a350 100644 --- a/use/web-apps/index.md +++ b/use/web-apps/index.md @@ -23,7 +23,7 @@ or mobile with [React native](https://facebook.github.io/react-native/). ### Option 2: Use WebSharper -![logo](../../images/thumbs/WebSharper.png) [WebSharper](http://websharper.com/) allows end-to-end web applications with both client and server developed in F#. +![logo](../../images/thumbs/WebSharper.png) [WebSharper](http://websharper.com/) allows end-to-end web applications with both client and server developed in F#. It includes TypeScript interoperability, mobile web apps, getting started material, templates and much more. * [Try Online](http://websharper.com/samples) @@ -56,4 +56,3 @@ coherent stack for type-safe, flexible, web-enabled applications that can be wri
There are other options, see also [F# Web Programming](../../guides/web/). -