Community Projects: Audio Processing
* [FSound](https://github.com/albertp007/FSound) - A sound processing library written in F#
-
diff --git a/guides/cloud/index.md b/guides/cloud/index.md
index 94a57af6..7521c00c 100644
--- a/guides/cloud/index.md
+++ b/guides/cloud/index.md
@@ -5,20 +5,20 @@ headline: Guide - Cloud Programming with F#
redirect_from: "/cloud/index.html"
---
-Cloud computing relies on leveraging multiple integrated services. Using multiple services required a unique set
-of technologies and capabilities, and F# excels in this domain. With the recent rise of cloud solutions, it is becoming increasingly easy to deploy multiple services "in the cloud", expanding what is possible both by storing large amounts of data and running heavy computations distributed across clusters of machines.
-The combination of built in support for asynchronous workflows, data processing capabilities, computation expressions,
-extensible syntax, composability, expressiveness for numeric code and more make F# uniquely suited to develop
-scalable cloud solutions efficiently.
+Cloud computing relies on leveraging multiple integrated services. Using multiple services required a unique set
+of technologies and capabilities, and F# excels in this domain. With the recent rise of cloud solutions, it is becoming increasingly easy to deploy multiple services "in the cloud", expanding what is possible both by storing large amounts of data and running heavy computations distributed across clusters of machines.
+The combination of built in support for asynchronous workflows, data processing capabilities, computation expressions,
+extensible syntax, composability, expressiveness for numeric code and more make F# uniquely suited to develop
+scalable cloud solutions efficiently.
-This guide is an overview of the packages and tools for scalable compute, messaging, storage, and data processing with F#,
-particularly for taking advantage of cloud-computing resources.
+This guide is an overview of the packages and tools for scalable compute, messaging, storage, and data processing with F#,
+particularly for taking advantage of cloud-computing resources.
For cloud-hosted web programming and services, refer to the [Web Programming Guide](../web/).
-
-
To contribute to this guide edit this page. These resources are for educational purposes.
-
+
To contribute to this guide edit this page. These resources are for educational purposes.
+
-
-
To contribute to this guide edit this page. These resources are for educational purposes.
-
+
To contribute to this guide edit this page. These resources are for educational purposes.
+
-
diff --git a/guides/data-science/index.md b/guides/data-science/index.md
index c80a3500..42aac87a 100644
--- a/guides/data-science/index.md
+++ b/guides/data-science/index.md
@@ -2,21 +2,21 @@
layout: default
title: Guide - Data Science | fsharp.org
headline: Guide - Data Science with F#
-redirect_from:
+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
+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.
+REPL-scripting, powerful libraries and scalable data integration.
-
-
To contribute to this guide edit this page. These resources are for educational purposes.
-
+
To contribute to this guide edit this page. These resources are for educational purposes.
+
-## Interactive Charting
+## 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#.
+* [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
@@ -53,13 +53,13 @@ effortlessly using .NET Core. Use .NET Interactive to build .NET Jupyter noteboo
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
+ * [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#.
@@ -80,12 +80,12 @@ If a resource specific to F# can't be found, then search for C# instead and adju
* [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.
+ * [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.
+ 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
@@ -96,38 +96,38 @@ If a resource specific to F# can't be found, then search for C# instead and adju
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
+ 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,
+
+ * [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.
+ 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
+ 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
+ * [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 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) -
@@ -142,10 +142,10 @@ If a resource specific to F# can't be found, then search for C# instead and adju
## Interoperability
-### F# and Excel
+### 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
+[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/)
@@ -177,10 +177,10 @@ 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
+### F# and MATLAB
{: #matlab-interop .anchor }
Resources:
@@ -189,7 +189,7 @@ Resources:
-### F# and Python
+### F# and Python
{: #python-interop .anchor }
Resources:
@@ -207,4 +207,3 @@ 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 26ff9ee7..d5b0d11c 100644
--- a/guides/engineering/issues.md
+++ b/guides/engineering/issues.md
@@ -4,21 +4,21 @@ title: Report/Fix an Issue | fsharp.org
headline: Report/Fix an Issue
---
-Please follow the links below to make a suggestion, report an issue with F# and/or contribute a fix.
+Please follow the links below to make a suggestion, report an issue with F# and/or contribute a fix.
### Core Language and Tools
|:------------------|:--------------------|:------------------|
-| [F# Language RFC](https://github.com/fsharp/fslang-design/) | [Make suggestion](https://github.com/fsharp/fslang-suggestions) | [Contribute to an RFC](https://github.com/fsharp/fslang-design/) |
-| [F# Language Specification](/specs/language-spec/) | [Make suggestion](https://github.com/fsharp/fslang-suggestions) | [Report/Fix an issue](/specs/language-spec/) |
-| [F# Compiler and Core Library](https://github.com/dotnet/fsharp) | [Make suggestion](https://github.com/fsharp/fslang-suggestions) | [Report/Fix an issue (general)](https://github.com/dotnet/fsharp/issues) |
+| [F# Language RFC](https://github.com/fsharp/fslang-design/) | [Make suggestion](https://github.com/fsharp/fslang-suggestions) | [Contribute to an RFC](https://github.com/fsharp/fslang-design/) |
+| [F# Language Specification](/specs/language-spec/) | [Make suggestion](https://github.com/fsharp/fslang-suggestions) | [Report/Fix an issue](/specs/language-spec/) |
+| [F# Compiler and Core Library](https://github.com/dotnet/fsharp) | [Make suggestion](https://github.com/fsharp/fslang-suggestions) | [Report/Fix an issue (general)](https://github.com/dotnet/fsharp/issues) |
### Editing Tools
|:--------------------|:------------------|:------------------|
| Visual Studio (F# Tools) | [Make suggestion](https://github.com/dotnet/fsharp) | [Report/Fix an issue](https://github.com/dotnet/fsharp/issues) |
| [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 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
@@ -26,10 +26,9 @@ Please follow the links below to make a suggestion, report an issue with F# and/
For other components and tools, please [refer to the relevant project](/community/projects). Some specific links are shown below.
|:------------------|:--------------------|:------------------|
-| [.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) |
+| [.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/gh-pages/guides/engineering/issues.md).
-
+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 44a2e63e..e51cfb32 100644
--- a/guides/enterprise/index.md
+++ b/guides/enterprise/index.md
@@ -11,7 +11,7 @@ The benefits of F# for enterprise development are:
* *Compatibility* - F# is completely integrated with the .NET platform and is a fully supported component of Visual Studio and JetBrains Rider. You can continue to use your favorite C# libraries and maintain your existing development processes.
-* *Low risk trials* - It's easier to learn F# than you might think. You can easily try out
+* *Low risk trials* - It's easier to learn F# than you might think. You can easily try out
F# for non-critical development tasks such as testing and scripting without committing to wholesale change.
* *Faster development time* - F# code is generally three times shorter than C# code. And F#
@@ -26,12 +26,12 @@ The benefits of F# for enterprise development are:
* *F# code is engineered for testing* - Functional programming does not use state and the logic tends to be linear,
so it is very easy to test subsystems in isolation easily (using NUnit or your favorite test framework),
- and there are no tangled webs of dependencies.
+ and there are no tangled webs of dependencies.
In addition, F# supports property-based testing with FsCheck.
* *Better domain modelling* - F# has a powerful type system that can be used to model domains accurately.
"Choice" types can model business cases more conveniently than inheritance, and business rules
- can be designed into the type system so that you get "compile-time unit tests", eliminating the need
+ can be designed into the type system so that you get "compile-time unit tests", eliminating the need
for many tests that would otherwise have to be written by hand.
* *Taming complexity* - F# has a number of features to help you manage complexity and improve performance such as:
@@ -42,9 +42,9 @@ The benefits of F# for enterprise development are:
* *Improving developer morale* - F# is a fun language to program in, and F# is a great way for developers
to learn new skills that will improve their skills in other languages, such as C# and JavaScript.
-
-
To contribute to this guide edit this page. These resources are for educational purposes.
-
+
To contribute to this guide edit this page. These resources are for educational purposes.
+
-
To contribute to this guide edit this page. These resources are for educational purposes.
-
+
To contribute to this guide edit this page. These resources are for educational purposes.
+
-
To contribute to this guide edit this page. These resources are for educational purposes.
-
+
To contribute to this guide edit this page. These resources are for educational purposes.
+
@@ -107,7 +107,7 @@ and mobile apps with [React native](https://facebook.github.io/react-native/).
#### Saturn
{: #saturn .anchor }
- [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.
+ [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.
It's heavily inspired by Elixir's [Phoenix](http://phoenixframework.org/).
@@ -153,7 +153,7 @@ It's heavily inspired by Elixir's [Phoenix](http://phoenixframework.org/).
------
-## Web Testing Frameworks
+## Web Testing Frameworks
{: .anchor }
@@ -161,9 +161,9 @@ It's heavily inspired by Elixir's [Phoenix](http://phoenixframework.org/).
#### 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
+[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
concise. You can easily leverage your existing .NET code to help you test.
-
+
#### Unit Testing Libraries
@@ -216,7 +216,7 @@ Please consider contributing, either directly to the TodoBackend project or via
Several books have been written that include information on building web applications with F#:
-* [Building Web, Cloud, and Mobile Solutions with F#](http://www.amazon.com/Building-Web-Cloud-Mobile-Solutions/dp/1449333761)
+* [Building Web, Cloud, and Mobile Solutions with F#](http://www.amazon.com/Building-Web-Cloud-Mobile-Solutions/dp/1449333761)
* [Expert F# 4.0](https://books.google.com/books?isbn=1484207424)
@@ -225,7 +225,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
+There are several presentations and tutorials available that include information on
build web applications with F#:
* [Taking F# to the Masses with CloudSharper](http://youtu.be/LvbfY3sl6Lo)
@@ -258,6 +258,3 @@ Common hosting options are:
* [AppHarbor](http://appharbor.com/) - Free hosting of .NET web applications
* [GearHost](https://www.gearhost.com/) - Free hosting of .NET web applications (100 MB), IIS based, support for both .NET Framework and [Core](https://www.gearhost.com/documentation/deploy-net-core-application), MSSQL and MySQL databases (10 MB), support of simple WebJobs.
-
-
-
diff --git a/teaching/research.md b/teaching/research.md
index 531df71f..e5b59865 100644
--- a/teaching/research.md
+++ b/teaching/research.md
@@ -7,22 +7,22 @@ headline: Publications related to F#
F# is about clarity of thinking and expression - "computational thinking made manifest" - and is loved by researchers
for bringing clear, concise problem solving techniques developed in academia into practice.
F# is acts as an inspiration for thousands of
-students and researchers worldwide. Many standard F# features (including _active patterns_ and _asynchronous workflows_)
+students and researchers worldwide. Many standard F# features (including _active patterns_ and _asynchronous workflows_)
have been described in publications, and many
-research projects build on top of F#.
+research projects build on top of F#.
[How to reference F# in a research paper.](https://dsyme.home.blog/2012/07/10/how-to-reference-f-in-a-research-paper/)
-To add a paper to this list [edit this page](https://github.com/fsharp/fsharp.org/edit/gh-pages/teaching/research.md) and submit a pull request.
+To add a paper to this list [edit this page](https://github.com/fsharp/fsharp.org/edit/main/teaching/research.md) and submit a pull request.
* **[F# Books](../learn/index.html#books)** - books about the F# language, including practical guides for using F# in practice.
* **[The F# Language - History and Design](#history)** - a publication
about the history and design of the F# language.
-
+
* **[Information-rich programming](#information-rich-programming)** - publications related to F# type providers, a novel mechanism
that integrates large-scale data into statically typed function programming language.
-
+
* **[Asynchronous, Concurrent and Reactive programming](#asynchronous-concurrent-and-reactive-programming)** - publications
about F# _asynchronous workflows_, the asynchronous programming model used in F#,
event-based programming and "joinads", a research extension of F# _computation expression_ syntax
@@ -31,13 +31,13 @@ To add a paper to this list [edit this page](https://github.com/fsharp/fsharp.or
* **[Parallel, Distributed and Cloud programming](#distributed-and-parallel-programming)** - publications
related to parallel and distributed programming using F#.
- * **[DSLs and Meta-programming](#dsls-and-meta-programming)** - publications related to DSL and
+ * **[DSLs and Meta-programming](#dsls-and-meta-programming)** - publications related to DSL and
meta-programming in F#.
* **[Units of Measure](#units-of-measure)** - publications related to the Units of Measure feature of F#.
* **[Web programming](#web-programming)** - publications related to web programming with F#.
-
+
* **[Security and Verification Research](#security-and-verification-research)** - variations of F# and their use in security and verification research.
* **[Applications](#applications)** - publications and presentations describing applications of F#.
@@ -45,7 +45,7 @@ To add a paper to this list [edit this page](https://github.com/fsharp/fsharp.or
--------------
-## The History of F#
+## The History of F#
{: #design .anchor }
### [The Early History of the F# Language](https://dl.acm.org/doi/pdf/10.1145/3386325)
@@ -61,7 +61,7 @@ This paper describes the genesis and early history of the F# programming languag
### [Types from data: Making structured data first-class citizens in F#](http://conf.researchr.org/event/pldi-2016/pldi-2016-papers-types-from-data-making-structured-data-first-class-citizens-in-f-)
-Tomas Petricek, Don Syme, Gustavo Guerra
+Tomas Petricek, Don Syme, Gustavo Guerra
[Distinguished Paper Award, _PLDI 2016_](http://conf.researchr.org/home/pldi-2016)
Most modern applications interact with external services and access data in structured formats such as XML, JSON and CSV. Static type systems do not understand such formats, often making data access more cumbersome. Should we give up and leave the messy world of external data to dynamic typing and runtime checks? Of course, not!
@@ -73,32 +73,32 @@ Our library significantly reduces the amount of data access code and it provides
### [F# 3.0 - Strongly-Typed Language Support for Internet-Scale Information Sources](http://research.microsoft.com/apps/pubs/default.aspx?id=173076)
-Don Syme et al.
+Don Syme et al.
_MSR Technical Report_
-A growing trend in both the theory and practice of programming is the interaction between
-programming and rich information spaces. From databases to web services to the semantic
-web to cloud-based data, the need to integrate programming with heterogeneous, connected,
-richly structured, streaming and evolving information sources is ever-increasing.
-Most modern applications incorporate one or more external information sources as integral components.
-
-Providing strongly typed access to these sources is a key consideration for strongly-typed
-programming languages, to insure low impedance mismatch in information access. At this scale,
-information integration strategies based on library design and code generation are manual,
-clumsy, and do not handle the internet-scale information sources now encountered in
-enterprise, web and cloud environments.
-
-In this report we describe the design and implementation
-of the type provider mechanism in F# 3.0 and its applications to typed programming
-with web ontologies, web-services, systems management information, database mappings,
-data markets, content management systems, economic data and hosted scripting. Type soundness
-becomes relative to the soundness of the type providers and the schema change in
-information sources, but the role of types in information-rich programming tasks is
+A growing trend in both the theory and practice of programming is the interaction between
+programming and rich information spaces. From databases to web services to the semantic
+web to cloud-based data, the need to integrate programming with heterogeneous, connected,
+richly structured, streaming and evolving information sources is ever-increasing.
+Most modern applications incorporate one or more external information sources as integral components.
+
+Providing strongly typed access to these sources is a key consideration for strongly-typed
+programming languages, to insure low impedance mismatch in information access. At this scale,
+information integration strategies based on library design and code generation are manual,
+clumsy, and do not handle the internet-scale information sources now encountered in
+enterprise, web and cloud environments.
+
+In this report we describe the design and implementation
+of the type provider mechanism in F# 3.0 and its applications to typed programming
+with web ontologies, web-services, systems management information, database mappings,
+data markets, content management systems, economic data and hosted scripting. Type soundness
+becomes relative to the soundness of the type providers and the schema change in
+information sources, but the role of types in information-rich programming tasks is
massively expanded, especially through tooling that benefits from rich types in explorative programming.
### [Themes in Information-Rich Functional Programming for Internet-Scale Data Sources](http://tomasp.net/academic/papers/inforich/)
-Don Syme et al.
+Don Syme et al.
_DDFP 2013_
The F# language includes a feature called F# 3.0 Type Providers to support the integration of internet-scale information sources into a strongly typed functional-first programming environment. In this position paper we describe the key themes in information-rich functional programming that we have observed during this work. Our contribution is to document these themes and highlight future challenges and opportunities, in the context of a recently released, practical, open-source system for information-rich functional programming. We believe that this area is rich in excellent opportunities for future language and tooling research, information-space integration and schematization techniques.
@@ -113,38 +113,38 @@ The F# language includes a feature called F# 3.0 Type Providers to support the i
### [The F# Asynchronous Programming Model](https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/async-padl-revised-v2.pdf)
-Don Syme, Tomas Petricek, Dmitry Lomov
+Don Syme, Tomas Petricek, Dmitry Lomov
_Proceedings of PADL 2011_
-We describe the asynchronous programming model in F#, and its applications to reactive,
-parallel and concurrent programming. The key feature combines a core language with a
-non-blocking modality to author lightweight asynchronous tasks, where the modality has
+We describe the asynchronous programming model in F#, and its applications to reactive,
+parallel and concurrent programming. The key feature combines a core language with a
+non-blocking modality to author lightweight asynchronous tasks, where the modality has
control flow constructs that are syntactically a superset of the core language and are given
-an asynchronous semantic interpretation. This allows smooth transitions between
-synchronous and asynchronous code and eliminates callback-style treatments of inversion
-of control, without disturbing the foundation of CPU-intensive programming that allows F# to
-interoperate smoothly and compile efficiently to .NET and native code.
+an asynchronous semantic interpretation. This allows smooth transitions between
+synchronous and asynchronous code and eliminates callback-style treatments of inversion
+of control, without disturbing the foundation of CPU-intensive programming that allows F# to
+interoperate smoothly and compile efficiently to .NET and native code.
### [Collecting Hollywood’s Garbage: Avoiding Space-Leaks in Composite Events](http://tomasp.net/academic/papers/hollywood/)
-Tomas Petricek, Don Syme
+Tomas Petricek, Don Syme
_Proceedings of ISMM 2010_
-The reactive programming model is largely different to what we’re used to as we don’t
-have full control over the application’s control flow. If we mix the declarative and
-imperative programming style, which is usual in the ML family of languages, the situation is
-even more complex. It becomes easy to introduce patterns where the usual garbage collector
-for objects cannot automatically dispose all components that we intuitively consider garbage.
-
-In this paper we discuss a duality between the definitions of garbage for objects and events.
-We combine them into a single one, to specify the notion of garbage for reactive programming
-model in a mixed functional/imperative language and we present a formal algorithm for
-collecting garbage in this environment.
-
-Building on top of the theoretical model, we implement a library for reactive programming
-that does not cause leaks when used in the mixed declarative/imperative model. The library
-allows us to safely combine both of the reactive programming patterns. As a result, we can
-take advantage of the clarity and simplicity of the declarative approach as well as the
+The reactive programming model is largely different to what we’re used to as we don’t
+have full control over the application’s control flow. If we mix the declarative and
+imperative programming style, which is usual in the ML family of languages, the situation is
+even more complex. It becomes easy to introduce patterns where the usual garbage collector
+for objects cannot automatically dispose all components that we intuitively consider garbage.
+
+In this paper we discuss a duality between the definitions of garbage for objects and events.
+We combine them into a single one, to specify the notion of garbage for reactive programming
+model in a mixed functional/imperative language and we present a formal algorithm for
+collecting garbage in this environment.
+
+Building on top of the theoretical model, we implement a library for reactive programming
+that does not cause leaks when used in the mixed declarative/imperative model. The library
+allows us to safely combine both of the reactive programming patterns. As a result, we can
+take advantage of the clarity and simplicity of the declarative approach as well as the
expressivity of the imperative model.
@@ -156,27 +156,27 @@ expressivity of the imperative model.
### [Joinads: a retargetable control-flow construct for reactive, parallel and concurrent programming](http://tomasp.net/academic/papers/joinads/)
-Tomas Petricek and Don Syme
+Tomas Petricek and Don Syme
_Proceedings of PADL 2011_
Modern challenges led to a design of a wide range of programming models for reactive,
-parallel and concurrent programming, but these are often difficult to encode in general
-purpose languages. We present an abstract type of computations called _joinads_ together
-with a syntactic language extension that aims to make it easier to use joinads in
-modern functional languages.
+parallel and concurrent programming, but these are often difficult to encode in general
+purpose languages. We present an abstract type of computations called _joinads_ together
+with a syntactic language extension that aims to make it easier to use joinads in
+modern functional languages.
-Our extension generalizes pattern matching to work on abstract computations. It keeps a
-familiar syntax and semantics of pattern matching making it easy to reason about code,
-even in a non-standard programming model. We demonstrate our extension using three important
-programming models – a reactive model based on events; a concurrent model based on join
-calculus and a parallel model using futures. All three models are implemented as libraries
-that benefit from our syntactic extension. This makes them easier to use and also opens
-space for exploring new useful programming models.
+Our extension generalizes pattern matching to work on abstract computations. It keeps a
+familiar syntax and semantics of pattern matching making it easy to reason about code,
+even in a non-standard programming model. We demonstrate our extension using three important
+programming models – a reactive model based on events; a concurrent model based on join
+calculus and a parallel model using futures. All three models are implemented as libraries
+that benefit from our syntactic extension. This makes them easier to use and also opens
+space for exploring new useful programming models.
### [The F# Computation Expression Zoo](http://tomasp.net/academic/papers/computation-zoo/)
-Tomas Petricek, Don Syme
+Tomas Petricek, Don Syme
_Proceedings of PADL 2014_
Many computations can be structured using abstract computation types such as monoids, monad transformers or applicative functors. Functional programmers use those abstractions directly while main-stream languages often integrate concrete instances as language features - e.g. generators in Python or asynchronous computations in C# 5.0. The question is, is there a sweet spot between convenient, hardwired language features, and an inconvenient but flexible libraries?
@@ -190,29 +190,29 @@ We show that computation expressions can structure well-known computations inclu
Claudio Russo, Matthew Windsor, Don Syme, Rupert Horlick, James Clarke
_Proceedings of ML 2016_
-Type classes are an immensely popular and productive feature of Haskell. They have since been adopted in,
-and adapted to, numerous other languages, including theorem provers.
+Type classes are an immensely popular and productive feature of Haskell. They have since been adopted in,
+and adapted to, numerous other languages, including theorem provers.
We show that type classes have a natural and efficient representation in .NET that paves
-the way for the extension of F#, C# and other .NET languages with type classes.
-Our encoding is type preserving and promises easy and safe cross-language inter-operation.
+the way for the extension of F#, C# and other .NET languages with type classes.
+Our encoding is type preserving and promises easy and safe cross-language inter-operation.
We have extended the open source C# compiler and language service, Roslyn,
with pervasive support for type classes and have prototyped a more minimalist design for F#.
### [Leveraging .NET meta-programming components from F#: integrated queries and interoperable heterogeneous execution](http://dl.acm.org/citation.cfm?doid=1159876.1159884)
-Don Syme
+Don Syme
_Proceedings of the 2006 workshop on ML_
-Language-integrated meta-programming and extensible compilation have been recurring themes of
-programming languages since the invention of LISP. A recent real-world application of these
-techniques is the use of small meta-programs to specify database queries, as used in the
-LINQ extensions for .NET. It is important that .NET languages such as F# are able to leverage
-the functionality provided by LINQ and related components for heterogeneous execution, both
-for pragmatic reasons and as a first step toward applying more disciplined, formal approaches
-to these problems. This paper explores the use of a modest meta-programming extension to F# to
-access and leverage the functionality of LINQ and other components. We do this by demonstrating
-an implementation of language integrated SQL queries using the LINQ/SQLMetal libraries. We also
-sketch two other applications: the execution of data-parallel quoted F# programs on a GPU via the
+Language-integrated meta-programming and extensible compilation have been recurring themes of
+programming languages since the invention of LISP. A recent real-world application of these
+techniques is the use of small meta-programs to specify database queries, as used in the
+LINQ extensions for .NET. It is important that .NET languages such as F# are able to leverage
+the functionality provided by LINQ and related components for heterogeneous execution, both
+for pragmatic reasons and as a first step toward applying more disciplined, formal approaches
+to these problems. This paper explores the use of a modest meta-programming extension to F# to
+access and leverage the functionality of LINQ and other components. We do this by demonstrating
+an implementation of language integrated SQL queries using the LINQ/SQLMetal libraries. We also
+sketch two other applications: the execution of data-parallel quoted F# programs on a GPU via the
Accelerator libraries, and dynamic native-code compilation via LINQ.
### [The F# Computation Expression Zoo](http://tomasp.net/academic/papers/computation-zoo/)
@@ -220,20 +220,20 @@ Accelerator libraries, and dynamic native-code compilation via LINQ.
Tomas Petricek and Don Syme
_In proceedings of PADL 2014_
-Many computations can be structured using abstract computation types such as monoids, monad
-transformers or applicative functors. Functional programmers use those abstractions directly while
-main-stream languages often integrate concrete instances as language features - e.g. generators in
-Python or asynchronous computations in C# 5.0. The question is, is there a sweet spot between
+Many computations can be structured using abstract computation types such as monoids, monad
+transformers or applicative functors. Functional programmers use those abstractions directly while
+main-stream languages often integrate concrete instances as language features - e.g. generators in
+Python or asynchronous computations in C# 5.0. The question is, is there a sweet spot between
convenient, hardwired language features, and an inconvenient but flexible libraries?
-F# computation expressions answer this question in the affirmative. Unlike the do notation in Haskell,
-computation expressions are not tied to a single kind of abstraction. They support a wide range of
-computations, depending on what operations are available. They also provide greater syntactic
+F# computation expressions answer this question in the affirmative. Unlike the do notation in Haskell,
+computation expressions are not tied to a single kind of abstraction. They support a wide range of
+computations, depending on what operations are available. They also provide greater syntactic
flexibility leading to a more intuitive syntax, without resorting to full macro-based meta-programming.
-We show that computation expressions can structure well-known computations including monoidal list
-comprehensions, monadic parsers, applicative formlets and asynchronous sequences based on the list
-monad transformer. We also present typing rules for computation expressions that are capable of
+We show that computation expressions can structure well-known computations including monoidal list
+comprehensions, monadic parsers, applicative formlets and asynchronous sequences based on the list
+monad transformer. We also present typing rules for computation expressions that are capable of
capturing all these applications.
--------------
@@ -293,7 +293,7 @@ and deployment of cloud services. Moreover, we show that
Prajna can harmonize cloud service and data analytical service,
and add rich data analytics on any existing cloud service/application.
Prajna supports running of cloud service and interactive data analytics in both managed code and unmanaged
-code, and supports running of remote code with significant data components (e.g., a recognition model that is hundreds of megabytes in size).
+code, and supports running of remote code with significant data components (e.g., a recognition model that is hundreds of megabytes in size).
--------------
@@ -370,66 +370,66 @@ flowlets defined in F# to JavaScript with WebSharper
Don Syme, Gregory Neverov, James Margetson
_Proceedings of ICFP 2007_
-Pattern matching of algebraic data types (ADTs) is a standard feature in typed functional
-programming languages, but it is well known that it interacts poorly with abstraction. While
-several partial solutions to this problem have been proposed, few have been implemented or
-used. This paper describes an extension to the .NET language F# called active patterns,
-which supports pattern matching over abstract representations of generic heterogeneous data
-such as XML and term structures, including where these are represented via object models in
-other .NET languages. Our design is the first to incorporate both ad hoc pattern matching
-functions for partial decompositions and "views" for total decompositions, and yet remains
-a simple and lightweight extension. We give a description of the language extension along
-with numerous motivating examples. Finally we describe how this feature would interact with
-other reasonable and related language extensions: existential types quantified at data
+Pattern matching of algebraic data types (ADTs) is a standard feature in typed functional
+programming languages, but it is well known that it interacts poorly with abstraction. While
+several partial solutions to this problem have been proposed, few have been implemented or
+used. This paper describes an extension to the .NET language F# called active patterns,
+which supports pattern matching over abstract representations of generic heterogeneous data
+such as XML and term structures, including where these are represented via object models in
+other .NET languages. Our design is the first to incorporate both ad hoc pattern matching
+functions for partial decompositions and "views" for total decompositions, and yet remains
+a simple and lightweight extension. We give a description of the language extension along
+with numerous motivating examples. Finally we describe how this feature would interact with
+other reasonable and related language extensions: existential types quantified at data
discrimination tags, GADTs, and monadic generalizations of pattern matching.
### [Initializing Mutually Referential Abstract Objects: The Value Recursion Challenge](http://research.microsoft.com/pubs/79951/valrec-final-ml-workshop.pdf)
-Don Syme
+Don Syme
_Proceedings of ML Workshop 2006_
-Mutual dependencies between objects arise frequently in programs, and programmers must
-typically solve this value recursion by manually filling "initialization holes" to help
-construct the corresponding object graphs, i.e. null values and/or explicitly mutable locations.
-This paper aims to augment ongoing theoretical work on value recursion with a description
-of a semi-safe mechanism for a generalized form of value recursion in an ML-like language,
-where initialization corresponds to a graph of lazy computations whose nodes are sequentially
-forced, requiring runtime checks for soundness during initialization in the style of Russo.
-Our primary contribution is to use the mechanism to develop compelling examples of how the
-absence of value recursion leads to real problems in the presence of abstraction boundaries,
-and give micro-examples that characterize how initialization graphs permit more programs to
-be expressed in the mutation-free fragment of ML. Finally we argue that in heterogeneous
-programming environments semi-safe variations on value-recursion may be appropriate for
-ML-like languages, because initialization effects from external libraries are difficult to
-characterize, document and control.
+Mutual dependencies between objects arise frequently in programs, and programmers must
+typically solve this value recursion by manually filling "initialization holes" to help
+construct the corresponding object graphs, i.e. null values and/or explicitly mutable locations.
+This paper aims to augment ongoing theoretical work on value recursion with a description
+of a semi-safe mechanism for a generalized form of value recursion in an ML-like language,
+where initialization corresponds to a graph of lazy computations whose nodes are sequentially
+forced, requiring runtime checks for soundness during initialization in the style of Russo.
+Our primary contribution is to use the mechanism to develop compelling examples of how the
+absence of value recursion leads to real problems in the presence of abstraction boundaries,
+and give micro-examples that characterize how initialization graphs permit more programs to
+be expressed in the mutation-free fragment of ML. Finally we argue that in heterogeneous
+programming environments semi-safe variations on value-recursion may be appropriate for
+ML-like languages, because initialization effects from external libraries are difficult to
+characterize, document and control.
### [Extending Monads with Pattern Matching](http://tomasp.net/academic/papers/docase/)
-Tomas Petricek, Alan Mycroft and Don Syme
+Tomas Petricek, Alan Mycroft and Don Syme
_Proceedings of Haskell Symposium 2011_
-Sequencing of effectful computations can be neatly captured using monads and elegantly
-written using `do` notation. In practice such monads often allow additional ways of
-composing computations, which have to be written explicitly using combinators.
+Sequencing of effectful computations can be neatly captured using monads and elegantly
+written using `do` notation. In practice such monads often allow additional ways of
+composing computations, which have to be written explicitly using combinators.
-We identify joinads, an abstract notion of computation that is stronger than monads
-and captures many such ad-hoc extensions. In particular, joinads are monads with three
-additional operations: one of type `m a -> m b -> m (a, b)` captures various forms of
-parallel composition, one of type `m a -> m a -> m a` that is inspired by choice and one
-of type `m a -> m (m a)` that captures aliasing of computations. Algebraically, the first
-two operations form a near-semiring with commutative multiplication.
+We identify joinads, an abstract notion of computation that is stronger than monads
+and captures many such ad-hoc extensions. In particular, joinads are monads with three
+additional operations: one of type `m a -> m b -> m (a, b)` captures various forms of
+parallel composition, one of type `m a -> m a -> m a` that is inspired by choice and one
+of type `m a -> m (m a)` that captures aliasing of computations. Algebraically, the first
+two operations form a near-semiring with commutative multiplication.
-We introduce `docase` notation that can be viewed as a monadic version of `case`. Joinad
-laws make it possible to prove various syntactic equivalences of programs written using
-`docase` that are analogous to equivalences about `case`. Examples of joinads that benefit
-from the notation include speculative parallelism, waiting for a combination of user
-interface events, but also encoding of validation rules using the intersection of parsers.
+We introduce `docase` notation that can be viewed as a monadic version of `case`. Joinad
+laws make it possible to prove various syntactic equivalences of programs written using
+`docase` that are analogous to equivalences about `case`. Examples of joinads that benefit
+from the notation include speculative parallelism, waiting for a combination of user
+interface events, but also encoding of validation rules using the intersection of parsers.
### [Try Joinads Demonstrator](http://tryjoinads.org/)
-Joinads is a general-purpose research extension of the F# computation expression syntax (also
-called _monadic syntax_) in F# and is mainly useful for concurrent, parallal and reactive
-programming. The extension adds a new piece of notation, written `match!` that can be
+Joinads is a general-purpose research extension of the F# computation expression syntax (also
+called _monadic syntax_) in F# and is mainly useful for concurrent, parallal and reactive
+programming. The extension adds a new piece of notation, written `match!` that can be
used to compose computations using non-deterministic choice, parallel composition and aliasing.
The best way to experiment with Joinads is to visit the [TryJoinads.org](http://tryjoinads.org/)
@@ -439,52 +439,52 @@ of running Silverlight (MacOS and Windows).
### [Evaluation strategies for monadic computations](http://tomasp.net/academic/papers/malias/)
-Tomas Petricek
+Tomas Petricek
_Proceedings of MSFP 2012_
-Monads have become a powerful tool for structuring effectful computations in functional
-programming, because they make the order of effects explicit. When translating pure code to a
-monadic version, we need to specify evaluation order explicitly. This requires us to choose
-between _call-by-value_ or _call-by-name_ style. The two translations give programs with
+Monads have become a powerful tool for structuring effectful computations in functional
+programming, because they make the order of effects explicit. When translating pure code to a
+monadic version, we need to specify evaluation order explicitly. This requires us to choose
+between _call-by-value_ or _call-by-name_ style. The two translations give programs with
different semantics, structure and also different types.
-In this paper, we translate pure code to monadic using an additional operation `malias`
-that abstracts out the evaluation strategy. The `malias` operation is based on _computational comonads_;
+In this paper, we translate pure code to monadic using an additional operation `malias`
+that abstracts out the evaluation strategy. The `malias` operation is based on _computational comonads_;
we use a categorical framework to specify the laws that are required to hold about the operation.
-We show two implementations of `malias` for any monad that give _call-by-value_ and
-_call-by-name_ semantics. Although we do not give _call-by-need_ semantics for any monad, we
-show how to turn any monad into an extended monad with _call-by-need_ semantics, which partly
-answers a standing open question. Moreover, using our unified translation, it is possible to
-change the evaluation strategy of functional code translated to the monadic form without
-changing its structure or types.
+We show two implementations of `malias` for any monad that give _call-by-value_ and
+_call-by-name_ semantics. Although we do not give _call-by-need_ semantics for any monad, we
+show how to turn any monad into an extended monad with _call-by-need_ semantics, which partly
+answers a standing open question. Moreover, using our unified translation, it is possible to
+change the evaluation strategy of functional code translated to the monadic form without
+changing its structure or types.
--------------
## Security and Verification Research
{: #security-and-verification-research .anchor }
-The experimental [FStar language](http://research.microsoft.com/en-us/projects/fstar/) is inspired by F#.
+The experimental [FStar language](http://research.microsoft.com/en-us/projects/fstar/) is inspired by F#.
Some of the publications about FStar are below.
-* Verifying Higher-order Programs with the Dijkstra Monad, Nikhil Swamy, Joel Weinberger, Cole Schlesinger,
+* Verifying Higher-order Programs with the Dijkstra Monad, Nikhil Swamy, Joel Weinberger, Cole Schlesinger,
Juan Chen, and Benjamin Livshits, in ACM Programming Language Design and Implementation (PLDI) 2013, ACM, June 2013
-* Self-Certification: Bootstrapping Certified Typecheckers in FStar with Coq, Pierre-Yves Strub, Nikhil Swamy,
- Cedric Fournet, and Juan Chen, in In Proceedings of the ACM Symposium on Principles on Programming Languages,
+* Self-Certification: Bootstrapping Certified Typecheckers in FStar with Coq, Pierre-Yves Strub, Nikhil Swamy,
+ Cedric Fournet, and Juan Chen, in In Proceedings of the ACM Symposium on Principles on Programming Languages,
ACM, January 2012
-* Secure Distributed Programming with Value-dependent Types, Nikhil Swamy, Juan Chen, Cedric Fournet, Pierre-Yves Strub, Karthikeyan Bharagavan, and Jean Yang,
+* Secure Distributed Programming with Value-dependent Types, Nikhil Swamy, Juan Chen, Cedric Fournet, Pierre-Yves Strub, Karthikeyan Bharagavan, and Jean Yang,
in The 16th ACM SIGPLAN International Conference on Functional Programming (ICFP 2011), ACM SIGPLAN, September 2011
-
-* Verified Security for Browser Extensions, Arjun Guha, Matthew Fredrikson, Benjamin Livshits, and Nikhil Swamy,
+
+* Verified Security for Browser Extensions, Arjun Guha, Matthew Fredrikson, Benjamin Livshits, and Nikhil Swamy,
in Proceedings of the IEEE Symposium on Security and Privacy (Oakland), IEEE, 22 May 2011
-
+
* Mechanized soundness proofs for FStar, Pierre-Yves Strub, Cedric Fournet, and Nikhil Swamy, 1 April 2011
-
-* Secure Distributed Programming with Value-Dependent Types, Nikhil Swamy, Juan Chen, Cedric Fournet,
+
+* Secure Distributed Programming with Value-Dependent Types, Nikhil Swamy, Juan Chen, Cedric Fournet,
Pierre-Yves Strub, Karthikeyan Bharagavan, and Jean Yang, no. MSR-TR-2011-37, 24 March 2011
-
+
--------------
@@ -505,23 +505,23 @@ F# plays a crucial role in helping the group process this data efficiently and d
Adam Granicz, IntelliFactory
_Commercial Users of Functional Programming (CUFP) 2012_
-With proprietary plugin-based containers like Flash or Silverlight gradually losing ground, an increasing
-number of web applications are beginning to seek web standards compliance, and to utilize HTML5 to deliver
-rich and interactive client-side functionality and end-user experience. Indeed, modern browsers continue
-to invest heavily in establishing standard support for various HTML5 features, making HTML5 an appropriate
+With proprietary plugin-based containers like Flash or Silverlight gradually losing ground, an increasing
+number of web applications are beginning to seek web standards compliance, and to utilize HTML5 to deliver
+rich and interactive client-side functionality and end-user experience. Indeed, modern browsers continue
+to invest heavily in establishing standard support for various HTML5 features, making HTML5 an appropriate
choice for an ever-growing crowd of web developers.
-Earlier this year at IntelliFactory, we completed a pilot project missioned to create a custom,
-innovative, and highly interactive bioinformatics web application using F# and our WebSharper technology.
-This application set out to serve the bioinformatics research community, and to deliver, among others,
-an interactive visualization of the gene sequence of a particular bacterium, with various mutations
-available for further research and laboratory use. The application consumed a large amount of bio data
-and integrated various advanced HTML5 visualizations, such as full functional gene ontology, a KEGG
+Earlier this year at IntelliFactory, we completed a pilot project missioned to create a custom,
+innovative, and highly interactive bioinformatics web application using F# and our WebSharper technology.
+This application set out to serve the bioinformatics research community, and to deliver, among others,
+an interactive visualization of the gene sequence of a particular bacterium, with various mutations
+available for further research and laboratory use. The application consumed a large amount of bio data
+and integrated various advanced HTML5 visualizations, such as full functional gene ontology, a KEGG
orthology, and a phenotype map, making it a useful web resource for researchers and laboratory staff alike.
-I will present our experience report on developing this bioinformatics application, the
-practices and guidelines related to client-based visualization projects we distilled while developing it,
-the challenges we met on the way, and how we solved these challenges. Many bioinformatics algorithms
+I will present our experience report on developing this bioinformatics application, the
+practices and guidelines related to client-based visualization projects we distilled while developing it,
+the challenges we met on the way, and how we solved these challenges. Many bioinformatics algorithms
are amenable to functional programming, but as a full-blown web application with advanced visualization
this project yielded a great deal of details that we hope will be useful for other attendees.
@@ -530,10 +530,10 @@ this project yielded a great deal of details that we hope will be useful for oth
Felienne Hermans, Danny Dig
-Spreadsheets are widely used in industry. It is estimated that end-user
-programmers outnumber regular programmers by a factor of 5. However, spreadsheets are
-error-prone: several reports exist of companies which have lost money because of
-spreadsheet errors. We assert that a contributing factor to these problems is the difficulty of
+Spreadsheets are widely used in industry. It is estimated that end-user
+programmers outnumber regular programmers by a factor of 5. However, spreadsheets are
+error-prone: several reports exist of companies which have lost money because of
+spreadsheet errors. We assert that a contributing factor to these problems is the difficulty of
consistent editing of spreadsheet formulas.
@@ -542,11 +542,11 @@ consistent editing of spreadsheet formulas.
Adam Granicz, IntelliFactory, Alex Peake, Veracentra
_Commercial Users of Functional Programming (CUFP) 2009_
-We have developed MarketingPlatform™ a marketing automation solution delivered as Software as a Service
-with F# as the primary language. MarketingPlatform™ is a solution for marketers in direct marketing and
-in channel marketing who would like to gain a timely and deep understanding of what is working and what
+We have developed MarketingPlatform™ a marketing automation solution delivered as Software as a Service
+with F# as the primary language. MarketingPlatform™ is a solution for marketers in direct marketing and
+in channel marketing who would like to gain a timely and deep understanding of what is working and what
is not working in their marketing campaigns. Marketers are than facilitated in the execution and delivery
-of campaigns, using this insight to create relevant communications to each individual. It is divided into
+of campaigns, using this insight to create relevant communications to each individual. It is divided into
four tightly integrated campaign management steps of Measure, Analyze, Design and Execute.
@@ -555,33 +555,33 @@ four tightly integrated campaign management steps of Measure, Analyze, Design an
Adam Granicz, IntelliFactory
_Commercial Users of Functional Programming (CUFP) 2011_
-Native mobile applications enjoyed tremendous success in recent years, and looking at various mobile
-application stores such as Apple's App Store or Google's Android Market reveals a staggering number of
-native mobile applications. As technologies to build these applications mature and the market saturates,
-mobile OS vendors are struggling to find ways to keep up with and secure the exponential market growth.
-Inhibiting factors include platform-specific development environments, programming languages, and
-building blocks for applications; developer-unfriendly licensing, policies and subscriptions; and
+Native mobile applications enjoyed tremendous success in recent years, and looking at various mobile
+application stores such as Apple's App Store or Google's Android Market reveals a staggering number of
+native mobile applications. As technologies to build these applications mature and the market saturates,
+mobile OS vendors are struggling to find ways to keep up with and secure the exponential market growth.
+Inhibiting factors include platform-specific development environments, programming languages, and
+building blocks for applications; developer-unfriendly licensing, policies and subscriptions; and
controlled channels of application distribution.
-These problems have given rise to many promising alternatives and technologies that aim to bridge
-across various mobile platforms and enable sharing some or all the code in between versions of
-applications for different mobile OSs. Two main directions unfolded: targeting mobile code generation
-from mainstream languages such as C# and Java, and embracing web applications with platform-independent
+These problems have given rise to many promising alternatives and technologies that aim to bridge
+across various mobile platforms and enable sharing some or all the code in between versions of
+applications for different mobile OSs. Two main directions unfolded: targeting mobile code generation
+from mainstream languages such as C# and Java, and embracing web applications with platform-independent
UI abstractions and enhanced access to the capabilities of the underlying device. While the technologies
-that enabled the former are an interesting topic, we believe that the latter has implications not only
-for mobile applications but also for their desktop counterparts, and finding ways to utilize functional
+that enabled the former are an interesting topic, we believe that the latter has implications not only
+for mobile applications but also for their desktop counterparts, and finding ways to utilize functional
programming in the development of these web-based applications has an immense impact on mobiles and desktops alike.
-
-In this talk I will highlight some of the work we are doing at IntelliFactory to enable building
+
+In this talk I will highlight some of the work we are doing at IntelliFactory to enable building
platform-independent mobile applications in F#. This work leverages our commercially available WebSharper
-framework, the premiere functional web development framework for F# with thousands of active users and
-partner companies, and utilizes some key functional programming abstractions that enable modeling
-first-class, type-safe, composable web applications and user interfaces. I will briefly outline the
-metaprogramming infrastructure that enables us to enlist arbitrary JavaScript libraries into the
-type-safe discipline of F#, and the underlying CoreJS language that is more amenable to reasoning about
+framework, the premiere functional web development framework for F# with thousands of active users and
+partner companies, and utilizes some key functional programming abstractions that enable modeling
+first-class, type-safe, composable web applications and user interfaces. I will briefly outline the
+metaprogramming infrastructure that enables us to enlist arbitrary JavaScript libraries into the
+type-safe discipline of F#, and the underlying CoreJS language that is more amenable to reasoning about
and applying code transformations and optimizations.
-
-At the end of the talk, I will briefly touch upon our upcoming F# in the Cloud support and how that
+
+At the end of the talk, I will briefly touch upon our upcoming F# in the Cloud support and how that
helps to seamlessly scale into the cloud desktop and mobile web applications with immense server computation needs.
@@ -591,7 +591,7 @@ Semen Grigorev, Saint Petersburg State University, Iakov Kirilenko, Saint Peters
_Central & Eastern European Software Engineering Conference in Russia (CEE-SECR '13) 2013_
-Abstract parsing is an important step of the processing of dynamically constructed statements or string-embedded
-languages (such as embedded or dynamic SQL). Existing LALR-based algorithms have performance issues. To increase performance we propose
-to use a GLR-algorithm as a base for abstract parsing and to reuse graph-structured stack and shared packed parse forest.
+Abstract parsing is an important step of the processing of dynamically constructed statements or string-embedded
+languages (such as embedded or dynamic SQL). Existing LALR-based algorithms have performance issues. To increase performance we propose
+to use a GLR-algorithm as a base for abstract parsing and to reuse graph-structured stack and shared packed parse forest.
RNGLR-algorithm modification for abstract parsing is presented.