| title | layout | order | summary |
|---|---|---|---|
Project Ideas |
default |
5 |
Review proposed projects and learn how to propose one of your own. |
This is a curated list of F# project ideas including:
- "nice-to-have" projects for groups and individuals to take up as part of a curriculum or independent learning
- ways to contribute to the F# open source community.
It is a great inspiration for students to work on a real-world projects, contributing to an open-source community.
Please add project ideas using the following format:
### Example Project Name
Description of project
**Contact**: name (title, email | phone)
**Tags**: comma, delimited, list, of, tags
Please submit your project ideas via Github pull request.
The F# type provider mechanism makes it possible to integrate external data sources into F#. One good example is the WorldBank type provider from F# Data, which implements type provider for a specific (and interesting) data source.
Another kind is the JSON type provider, which implements type provider for a speicfic data format (using type inference mechanism), but it can work with any JSON files.
There is a number of interesting data sources and creating a type provider for them would be an interesting project:
- Open government data sources: EU open data, UK open data and US open data
- Yahoo Finance type provider for accessing stock prices
- PDF type provider for extracting tables from PDF
- Various REST description formats like RAML, WADL an API Blueprint
Contact: Tomas Petricek (tomas@tomasp.net or @tomaspetricek
Tags: type providers, api, rest, web, data
Domain specific languages (DSLs) give a powerful technique for writing reusable libraries (not just) in functional languages. Given a problem (i.e. processing lists), we design a set of reusable combinators (mapping, filtering, etc.). A specific problem (such as a task to multiply elements of two lists by some number and then combine them in some way) can then be easily solved just by using the available combinators.
The approach is used not just for list processing, but in many other areas - for composing user interfaces, specifying event handling, modelling financial contracts, etc. Here is an example of list processing (using F#):
List.zip
(list1 |> List.map (fun x -> x * 10))
(list2 |> List.map (fun x -> x * -10))
|> List.iter (fun (a, b) -> printfn "left %d, right %d" a b)
The code can be quite nicely represented visually, showing how the data flow through the combinators:
The idea of this project is to design some editor (or, at least, visualizer) that can take code written using DSL and display it visually and allow the user to edit it. This should work for any DSL (although it may need to be annotated in some way).
Contact: Tomas Petricek (tomas@tomasp.net or @tomaspetricek
Tags: dsl, user interface, visual programming
In statically typed programming languages like F#, the type system is used to check that types of expressions are used correctly and are correctly composed (i.e. you call a function with an argument of a correct type).
However, sometimes we do not quite surely know what the type of an expression is. This may be because we're calling some dynamically typed code (JavaScript interop) or because we're loading data from an external data source that does not have a clear type.
The goal of this project is to create a "fuzzy" type system that can deal with such uncertainty in programs. For example, if the type system can tell us that the property Name is a string in 99% of the cases, then that's quite useful information!
This is probably more theoretical or experimental project, but it could be implemented as a simple language (i.e. for data processing) or it could be written as an additional checker on top of some F# type provider (or it could be integrated in a type provider). On the thoery side, there might be some connection with Fuzzy Logic.
Contact: Tomas Petricek (tomas@tomasp.net or @tomaspetricek
Tags: types, fuzzy logic, checking, static, dynamic
NOTE: This is a temporary page; we are working on a new website that will provide a form for submitting and searching for projects.